模型抽象层

        run: |
          TODAY=$(date -u +%Y-%m-%d)
          export SKILL_NAME
          CONFIG_MODEL=$(grep -E '^model:' aeon.yml | sed 's/^model: *//' | tr -d ' ')
          # Check for per-skill model override in aeon.yml (extract quoted value, ignore comments)
          SKILL_MODEL=$(grep "^  ${SKILL_NAME}:" aeon.yml | sed -n 's/.*model: *"\([^"]*\)".*/\1/p')
          if [ -n "$INPUT_MODEL" ] && [ "$INPUT_MODEL" != "(config default)" ]; then
            MODEL="$INPUT_MODEL"
          elif [ -n "$SKILL_MODEL" ]; then
            MODEL="$SKILL_MODEL"
          else
            MODEL="${CONFIG_MODEL:-claude-opus-4-8}"
          fi

@export_module("autogen")
class ModelClient(Protocol):
    """A client class must implement the following methods:
    - create must return a response object that implements the ModelClientResponseProtocol
    - cost must return the cost of the response
    - get_usage must return a dict with the following keys:
        - prompt_tokens
        - completion_tokens
        - total_tokens
        - cost
        - model

            handoff_reminder (str | None): Custom reminder for handoffs.
                Defaults to `Transfer completed. You are {recipient_agent_name}. Please continue the task.`

        ## OpenAI Agents SDK Parameters:
            prompt (Prompt | DynamicPromptFunction | None): Dynamic prompt configuration.
            model (str | Model | None): Model identifier (e.g., "gpt-5.4") or Model instance.
                Defaults to "gpt-5.4-mini".
            model_settings (ModelSettings | None): Model configuration (temperature, max_tokens, etc.).
            tools (list[Tool] | None): Tool instances for the agent. Defaults to empty list.
            mcp_servers (list[MCPServer] | None): Model Context Protocol servers.
            mcp_config (MCPConfig | None): MCP server configuration.
            input_guardrails (list[InputGuardrail] | None): Pre-execution validation checks.
            output_guardrails (list[OutputGuardrail] | None): Post-execution validation checks.

_AI_PROVIDER_CACHE_TTL = 300  # 5 minutes cache TTL


def _get_ai_provider_extensions(use_cache=True):
    """Get all extension files with CATEGORY = 'AI Provider'

    Args:
        use_cache: If True, use cached results when available (default: True)
    """
    global _ai_provider_cache, _ai_provider_cache_time

    # Return cached result if valid
    if use_cache and _ai_provider_cache is not None:

 * Callers like AgentNode should use `setCurrentUsageCallback` before invoking methods like `streamText`
 * or `generateText` to ensure usage is captured for state updates or other tracking purposes.
 */
export class CoreLLM {
  private model: LanguageModel;
  private config: LLMConfig;
  private lastTokenUsage: TokenUsage | null = null;

  constructor({ model, config }: { model: LanguageModel; config: LLMConfig }) {
    this.model = model;
    this.config = config;

    logger.debug(LogCategory.LLM, 'CoreLLM', 'Created LLM instance', {

_openai = None


def _get_litellm():
    """Lazy import of litellm - only loads when AI features are used."""
    global _litellm
    if _litellm is None:
        try:
            import litellm

            litellm.suppress_debug_info = True
            _litellm = litellm
        except Exception:  # pragma: no cover

)


def resolve_model(model: str) -> Any:
    """Resolve an ACE/LiteLLM model string for PydanticAI.

    Returns either a string (for PydanticAI's auto-provider detection)
    or a ``(provider, model_name)`` tuple when explicit provider
    configuration is needed (e.g. Bedrock API key auth).

    Resolution paths:

    1. **PydanticAI-native prefix** -- Already starts with a known

_TOOL_CHOICE_LITERAL_MODES = {"auto", "none", "required"}


class ChatModelBase:
    """The base class for chat models."""

    class Parameters(BaseModel):
        """Each subclass should implement this inner class to define its
        parameters."""

    credential: CredentialBase
    """The API credential."""

  "openai:gpt-5-nano": "gpt-5-nano",
};

export const getNamespaceLanguageModel = (
  model: LLM = DEFAULT_LLM,
): LanguageModel => {
  const modelId = modelToId[model];
  return openaiAzure.languageModel(modelId);
};

    pass


class BaseLLM(BaseModel):
    args: BaseModelArgs = Field(default_factory=BaseModelArgs)
    max_retry: int = Field(default=3)
    client_args: Optional[Dict] = Field(default={})
    is_azure: bool = Field(default=False)

    @abstractmethod
    def get_spend(self) -> float:
        """
        Number of USD spent

}

#[maybe_send_sync]
pub trait LangModelInference {
    /// Runs the language model with the given tools and messages, returning a stream of `MessageOutput`s.
    fn infer_delta<'a>(
        &'a mut self,
        msgs: Vec<Message>,
        tools: Vec<ToolDesc>,
        docs: Vec<Document>,
        config: LangModelInferConfig,
    ) -> BoxStream<'a, anyhow::Result<MessageDeltaOutput>>;

def orjson_dumps(
    v: Any, *, default: Any = None, sort_keys: bool = False, indent_2: bool = True
) -> str:
    """
    Serialize Python objects to JSON string using orjson with custom options.

    :param v: Object to serialize
    :param default: Default function for non-serializable objects
    :param sort_keys: Whether to sort dictionary keys
    :param indent_2: Whether to use 2-space indentation
    :return: JSON string representation

            )


class ChatCompletionClient(ComponentBase[BaseModel], ABC):
    # Caching has to be handled internally as they can depend on the create args that were stored in the constructor
    @abstractmethod
    async def create(
        self,
        messages: Sequence[LLMMessage],
        *,
        tools: Sequence[Tool | ToolSchema] = [],
        tool_choice: Tool | Literal["auto", "required", "none"] = "auto",
        json_output: Optional[bool | type[BaseModel]] = None,

    return def
  }

  public async generateContent(input: InputProps): Promise<Response> {
    const primaryInputModel = this._getPrimaryModel(input)

    if (!this._useBeta || !isKnownV2Model(primaryInputModel)) {
      return this._generateContent(input)
    }

    try {
      return await this._generateContentV2(input)
    } catch (err) {

        return None


def create_llm(model: str, api_key: Optional[str] = None, **kwargs) -> LLM:
    """Factory function to create the appropriate LLM based on model name.
    
    Args:
        model: The model name (e.g., "gpt-4o", "claude-3-5-sonnet", "gemini-1.5-pro")
        api_key: Optional API key to override environment variable
        **kwargs: Additional arguments to pass to the LLM constructor
    
    Returns:
        An LLM instance for the specified model

    }

    /// Extract memories from conversation
    pub async fn extract_memories(&self, prompt: &str) -> Result<MemoryExtractionResponse> {
        let response: String = self.complete(prompt).await?;
        
        // Extract JSON from response (handles markdown code blocks)
        let json_str = Self::extract_json_from_response_static(&response);
        
        // Try to parse as structured response first
        if let Ok(extracted) = serde_json::from_str::<MemoryExtractionResponse>(json_str) {
            tracing::debug!("Successfully parsed MemoryExtractionResponse");
            return Ok(extracted);

    return call_id


class BaseLLM(BaseModel, ABC):
    """Abstract base class for LLM implementations.

    This class defines the interface that all LLM implementations must follow.
    Users can extend this class to create custom LLM implementations that don't
    rely on litellm's authentication mechanism.

    Custom LLM implementations should handle error cases gracefully, including
    timeouts, authentication failures, and malformed responses. They should also
    implement proper validation for input parameters and provide clear error

  return { ...credentials, ANTHROPIC_API_KEY: eapApiKey };
}

export async function getLLM(
  auth: Authenticator,
  {
    credentials,
    getTraceInput,
    getTraceOutput,
    modelId,
    temperature,
    reasoningEffort,
    responseFormat,

from haystack.dataclasses import ChatMessage


class ChatGenerator(Protocol):
    """
    Protocol for Chat Generators.

    This protocol defines the minimal interface that Chat Generators must implement.
    Chat Generators are components that process a list of `ChatMessage` objects as input and generate
    responses using a Language Model. They return a dictionary.
    """

    def run(self, messages: list[ChatMessage]) -> dict[str, Any]:

        return "hermes-cli"


@dataclass
class ProviderProfile:
    """Base provider profile — subclass or instantiate with overrides."""

    # ── Identity ─────────────────────────────────────────────
    name: str
    api_mode: str = "chat_completions"
    aliases: tuple = ()

    # ── Human-readable metadata ───────────────────────────────

    is_skill_content: bool = False  # AS-10: marks activated skill body, protected from pruning


class LLMProvider(ABC):
    """
    Abstract LLM provider - plug in any LLM backend.

    Implementations should handle:
    - API authentication
    - Request/response formatting
    - Token counting
    - Error handling
    """

        return res


class BaseLLM:
    """Base class for model wrapper.

    Args:
        path (str): The path to the model.
        max_new_tokens (int): Maximum length of output expected to be generated by the model. Defaults
            to 512.
        tokenizer_only (bool): If True, only the tokenizer will be initialized.
            Defaults to False.
        meta_template (list of dict, optional): The model's meta prompt

        _ssrf_client = ssrf_safe_client(
            verify=global_ssl_context, follow_redirects=False
        )
    return _ssrf_client


_MODEL_PROFILES = cast(ModelProfileRegistry, _PROFILES)


def _get_default_model_profile(model_name: str) -> ModelProfile:
    default = _MODEL_PROFILES.get(model_name) or {}
    return default.copy()

from termcolor import colored


def check_model_is_available(client: LlamaStackClient, model: str):
    available_models = [
        model.identifier
        for model in client.models.list()
        if model.model_type == "llm" and "guard" not in model.identifier
    ]

    if model not in available_models:
        print(
            colored(

from llama_index.core.schema import BaseComponent


class BaseLLM(BaseComponent, DispatcherSpanMixin):
    """BaseLLM interface."""

    model_config = ConfigDict(arbitrary_types_allowed=True)
    callback_manager: CallbackManager = Field(
        default_factory=lambda: CallbackManager([]), exclude=True
    )
    # Expected type: BaseRateLimiter (from llama_index.core.rate_limiter)
    rate_limiter: Optional[Any] = Field(
        default=None,

from typing import List


class ChatLLM(BaseModel):
    model: str = 'gpt-3.5-turbo'
    temperature: float = 0.0
    openai.api_key = os.environ["OPENAI_API_KEY"]  # Credentials setup

    def generate(self, prompt: str, stop: List[str] = None):
        response = openai.ChatCompletion.create(
            model=self.model,
            messages=[{"role": "user", "content": prompt}],
            temperature=self.temperature,

logger = get_logger(__name__)


class LiteLLMModel(BaseLLMModel):
    """
    LoongFlow model backend implementation based on LiteLLM.

    Each model instance holds static configuration (model name, base_url, api_key),
    while each `generate` call handles dynamic per-request parameters
    (messages, tools, temperature, etc.).
    """

    def __init__(

import os
from anthropic import Anthropic
import re
from rich.console import Console
from rich.panel import Panel
from datetime import datetime
import json
from tavily import TavilyClient

# Set up the Anthropic API client
client = Anthropic(api_key="YOUR KEY")

 */
export const gateways = defaultGateways;

export class ModelRouterLanguageModel implements MastraLanguageModelV2 {
  readonly specificationVersion = 'v2' as const;
  readonly defaultObjectGenerationMode = 'json' as const;
  readonly supportsStructuredOutputs = true;
  readonly supportsImageUrls = true;

  /**
   * Supported URL patterns by media type for the provider.
   * This is a lazy promise that resolves the underlying model's supportedUrls.
   * Models like Mistral define which URL patterns they support (e.g., application/pdf for https URLs).

from metagpt.utils.token_counter import TOKEN_MAX


class BaseLLM(ABC):
    """LLM API abstract class, requiring all inheritors to provide a series of standard capabilities"""

    config: LLMConfig
    use_system_prompt: bool = True
    system_prompt = "You are a helpful assistant."

    # OpenAI / Azure / Others
    aclient: Optional[Union[AsyncOpenAI]] = None
    cost_manager: Optional[CostManager] = None

}

// Provides a generic interface for interacting with an AI model.
type Model[TIn, TOut any] interface {
	Info() *ModelInfo
	Invoke(input *TIn) (*TOut, error)
}

// Provides a generic interface for setting the model information (used internally).
type modelPtr[TModel any] interface {
	*TModel
	setInfo(info *ModelInfo)
}

_SYNTHETIC_USER_CONTENT = "(conversation continued)"


class LLMProvider(ABC):
    """Base class for LLM providers."""

    supports_progress_deltas = False

    _CHAT_RETRY_DELAYS = (1, 2, 4)
    _PERSISTENT_MAX_DELAY = 60
    _PERSISTENT_IDENTICAL_ERROR_LIMIT = 10
    _RETRY_HEARTBEAT_CHUNK = 30
    _TRANSIENT_ERROR_MARKERS = (

 * @param region   - Optional AWS region for `bedrock`; falls back to `AWS_REGION` env var, then `'us-east-1'`. Ignored by all other providers.
 * @throws {Error} When the provider string is not recognised.
 */
export async function createAdapter(
  provider: SupportedProvider,
  apiKey?: string,
  baseURL?: string,
  region?: string,
): Promise<LLMAdapter> {
  switch (provider) {
    case 'anthropic': {
      const { AnthropicAdapter } = await import('./anthropic.js')
      return new AnthropicAdapter(apiKey, baseURL)

}

// Model interface for the unified model system
export interface Model<TApi extends Api = Api> {
  id: string;
  name: string;
  api: TApi;
  provider: Provider;
  baseUrl: string;
  reasoning: boolean;
  /**
   * Maps OpenClaw thinking levels to provider/model-specific values.
   * Missing keys use provider defaults. null marks a level as unsupported.

TAdapter = TypeVar("TAdapter", bound=BaseLLMAdapter, default=BaseLLMAdapter)


class LLMService(UserTurnCompletionLLMServiceMixin, AIService, Generic[TAdapter]):
    """Base class for all LLM services.

    Handles function calling registration and execution with support for both
    parallel and sequential execution modes. Provides event handlers for
    completion timeouts and function call lifecycle events.

    The service supports the following event handlers:

    - on_completion_timeout: Called when an LLM completion timeout occurs

            'audio_output_tokens': self.audio_output_tokens,
        }

class LLM:
    """
    Easy to use wrapper for language models. Supports multiple providers like OpenAI, 
    Anthropic, and others through LiteLLM.
    """
    
    # Class-level flag for one-time logging configuration
    _logging_configured = False
    
    # Class-level cache for LiteLLM module (avoids repeated import overhead)

/// <summary>
/// Interface for chat completion services.
/// </summary>
public interface IChatCompletionService : IAIService
{
    /// <summary>
    /// Get chat multiple chat content choices for the prompt and settings.
    /// </summary>
    /// <remarks>
    /// This should be used when the settings request for more than one choice.
    /// </remarks>
    /// <param name="chatHistory">The chat history context.</param>
    /// <param name="executionSettings">The AI execution settings (optional).</param>

REMOVE_PARAMETER = _ParameterRemove()


class Model:
    """Base class for all language model implementations.

    This abstract class defines the core interface that all model implementations must follow
    to work with agents. It provides common functionality for message handling, tool integration,
    and model configuration while allowing subclasses to implement their specific generation logic.

    Parameters:
        flatten_messages_as_text (`bool`, default `False`):
            Whether to flatten complex message content into plain text format.

    ttl: str | None = None


class Model(abc.ABC):
    """Abstract base class for Agent model providers.

    This class defines the interface for all model implementations in the Strands Agents SDK. It provides a
    standardized way to configure and process requests for different AI model providers.
    """

    @property
    def stateful(self) -> bool:
        """Whether the model manages conversation state server-side.

from typing import List, Callable, Union

# Package/library imports
from openai import OpenAI


# Local imports
from .util import function_to_json, debug_print, merge_chunk
from .types import (
    Agent,
    AgentFunction,
    ChatCompletionMessage,
    ChatCompletionMessageToolCall,

 * Uses the provider registry for endpoint defaults — no hardcoded provider list.
 * Anthropic is the only special case (different LangChain class); everything else is OpenAI-compatible.
 */
export function buildChatModel(opts: {
  provider: string
  model: string
  ollamaMode?: 'local' | 'cloud' | null
  apiKey: string | null
  credentialId?: string | null
  apiEndpoint?: string | null
  thinkingLevel?: 'minimal' | 'low' | 'medium' | 'high'
  responseFormat?: GenerationResponseFormat
}) {

        return response_content


class LiteLLM:
    """
    A comprehensive wrapper for LiteLLM that provides a unified interface for interacting
    with various Large Language Models (LLMs).

    This class supports multiple model providers including OpenAI, Anthropic, Google,
    and many others through the LiteLLM library. It provides features such as:

    - Text generation with customizable parameters
    - Vision capabilities (image understanding)

    # No alias found, return original
    return model_id

def infer_model(  # noqa: C901
    model: Model | KnownModelName | str, provider_factory: Callable[[str], Provider[Any]] = infer_provider
) -> Model:
    """Infer the model from the name.

    Args:
        model:
            Model name to instantiate, in the format of `provider/model`. Use the string "test" to instantiate TestModel.
        provider_factory:
            Function that instantiates a provider object. The provider name is passed into the function parameter. Defaults to `provider.infer_provider`.

        _llm_cache.clear()


def get_llm(role: LLMRole, config: Optional[AgentConfig] = None) -> LLM:
    """
    Get the LLM for the specified role, using the provided config
    or a default if none is provided.

    Uses a cache based on configuration parameters to avoid repeated LLM instantiation.
    """
    if config is None:
        config = AgentConfig()
    # Check cache first

type EmbeddingModelInstance = Exclude<EmbeddingModel, string>;
export type EmbeddingModelFactory = (modelId: string) => EmbeddingModelInstance;

export type ModelProvider = {
  languageModel: LanguageModelFactory;
  embeddingModel?: EmbeddingModelFactory;
  embedding?: EmbeddingModelFactory;
  textEmbeddingModel?: EmbeddingModelFactory;
  textEmbedding?: EmbeddingModelFactory;
};

export type ModelProviderEntry = ModelProvider | LanguageModelFactory;
export type ModelProviderLoader = () => Promise<ModelProviderEntry>;