Migrating to 1.0

from pipecat.services.openai.llm import OpenAILLMService
from pipecat.processors.aggregators.openai_llm_context import OpenAILLMContext

# Service-specific context
context = OpenAILLMContext(messages, tools)

# Service-specific aggregator factory
context_aggregator = llm.create_context_aggregator(context)

pipeline = Pipeline([
    transport.input(),
    stt,
    context_aggregator.user(),
    llm,
    tts,
    transport.output(),
    context_aggregator.assistant(),
])

from pipecat.services.openai.llm import OpenAILLMService
from pipecat.processors.aggregators.llm_context import LLMContext
from pipecat.processors.aggregators.llm_response_universal import LLMContextAggregatorPair
from pipecat.adapters.schemas.function_schema import FunctionSchema
from pipecat.adapters.schemas.tools_schema import ToolsSchema

# Universal context — works with any LLM provider
tools = ToolsSchema(standard_tools=[
    FunctionSchema(
        name="get_weather",
        description="Get current weather",
        properties={"location": {"type": "string", "description": "City name"}},
        required=["location"],
    )
])
context = LLMContext(messages=messages, tools=tools)

# Universal aggregator
user_aggregator, assistant_aggregator = LLMContextAggregatorPair(context)

pipeline = Pipeline([
    transport.input(),
    stt,
    user_aggregator,
    llm,
    tts,
    transport.output(),
    assistant_aggregator,
])

from pipecat.pipeline.pipeline import Pipeline
from pipecat.pipeline.task import PipelineParams, PipelineTask
from pipecat.processors.user_idle_processor import UserIdleProcessor

# Interruptions configured on the pipeline task
task = PipelineTask(
    pipeline,
    params=PipelineParams(allow_interruptions=True),
)

# Separate idle processor
idle = UserIdleProcessor(timeout=5.0, callback=handle_idle)

# STTMuteFilter
stt_mute_filter = STTMuteFilter(
    config=STTMuteConfig(strategies={STTMuteStrategy.FIRST_SPEECH})
)

pipeline = Pipeline([
    transport.input(),
    stt,
    stt_mute_filter,
    idle,
    context_aggregator.user(),
    llm,
    tts,
    transport.output(),
    context_aggregator.assistant(),
])

from pipecat.processors.aggregators.llm_response_universal import (
    LLMContextAggregatorPair,
    LLMUserAggregatorParams,
)
from pipecat.audio.vad.silero import SileroVADAnalyzer
from pipecat.turns.user_turn_strategies import UserTurnStrategies

# Everything configured on the aggregator
user_aggregator, assistant_aggregator = LLMContextAggregatorPair(
    context,
    user_params=LLMUserAggregatorParams(
        user_turn_strategies=[
            UserTurnStrategies(
                start=[
                    # Start strategies
                ],
                stop=[
                    # Stop strategies
                ],
            ),
        ],
        user_mute_strategies=[
            # Mute strategies
        ],
        user_turn_stop_timeout=5.0,
        user_idle_timeout=8.0,
        vad_analyzer=SileroVADAnalyzer(),
    ),
)

from pipecat.transports.services.daily import DailyParams, DailyTransport
from pipecat.audio.vad.silero import SileroVADAnalyzer
from pipecat.audio.vad.vad_analyzer import VADParams

transport = DailyTransport(
    room_url,
    token,
    "Bot",
    DailyParams(
        vad_enabled=True,
        vad_audio_passthrough=True,
        vad_analyzer=SileroVADAnalyzer(params=VADParams(stop_secs=0.2)),
        turn_analyzer=LocalSmartTurnAnalyzerV3(params=SmartTurnParams()),
    ),
)

from pipecat.transports.daily.transport import DailyTransport, DailyParams
from pipecat.audio.vad.silero import SileroVADAnalyzer

transport = DailyTransport(
    room_url,
    token,
    "Bot",
    DailyParams(
        audio_in_enabled=True,
        audio_out_enabled=True,
    ),
)

# VAD is now configured on the aggregator
user_aggregator, assistant_aggregator = LLMContextAggregatorPair(
    context,
    user_params=LLMUserAggregatorParams(
        vad_analyzer=SileroVADAnalyzer(),
    ),
)

# Before (1.0)
from pipecat.services.openai import OpenAILLMService

# After (1.0)
from pipecat.services.openai.llm import OpenAILLMService