memeloop 0.0.1 → 0.1.1

package/dist/interface-IrKBFtL1.d.ts

@@ -0,0 +1,493 @@
+declare const ORCHESTRATION_ERROR_CODES: readonly ["UNSUPPORTED", "FORBIDDEN", "CONFLICT", "STALE_EPOCH", "NOT_FOUND", "INVALID", "EXHAUSTED", "UNAVAILABLE", "TIMEOUT", "CANCELLED", "UNKNOWN_EFFECT", "WATCH_COMPACTED", "INTERNAL"];
+type OrchestrationErrorCode = typeof ORCHESTRATION_ERROR_CODES[number];
+interface OrchestrationErrorData {
+    code: OrchestrationErrorCode;
+    message: string;
+    retryable: boolean;
+    retryAfterMs?: number;
+    reason?: string;
+    details?: Record<string, unknown>;
+}
+declare class OrchestrationError extends Error {
+    readonly code: OrchestrationErrorCode;
+    readonly retryable: boolean;
+    readonly retryAfterMs?: number;
+    readonly reason?: string;
+    readonly details?: Record<string, unknown>;
+    constructor(data: OrchestrationErrorData);
+    toJSON(): OrchestrationErrorData;
+}
+declare function isOrchestrationError(error: unknown): error is OrchestrationError;
+declare function toOrchestrationErrorData(error: unknown, fallback?: Pick<OrchestrationErrorData, 'code' | 'retryable'>): OrchestrationErrorData;
+
+interface OrchestrationTypeMeta {
+    apiVersion: string;
+    kind: string;
+}
+interface OrchestrationOwnerReference extends OrchestrationTypeMeta {
+    name: string;
+    uid: string;
+    controller?: boolean;
+}
+interface OrchestrationManifestMetadata {
+    name?: string;
+    generateName?: string;
+    namespace?: string;
+    labels?: Record<string, string>;
+    annotations?: Record<string, string>;
+    ownerReferences?: OrchestrationOwnerReference[];
+    finalizers?: string[];
+}
+interface OrchestrationObjectMetadata extends OrchestrationManifestMetadata {
+    name: string;
+    uid: string;
+    generation: number;
+    resourceVersion: string;
+    creationTimestamp: string;
+    deletionTimestamp?: string;
+    deletionGracePeriodSeconds?: number;
+}
+type OrchestrationConditionStatus = 'True' | 'False' | 'Unknown';
+interface OrchestrationCondition {
+    type: string;
+    status: OrchestrationConditionStatus;
+    reason: string;
+    lastTransitionTime: string;
+    message?: string;
+    observedGeneration?: number;
+}
+interface OrchestrationResourceStatus {
+    /** Generation observed by the controller that last wrote this status. */
+    observedGeneration?: number;
+    /** Conditions set by the controller or verifier. */
+    conditions?: OrchestrationCondition[];
+    /**
+     * Status reported by the actor (worker/node), kept separate from
+     * controller-observed fields so a compromised actor cannot overwrite
+     * controller decisions. Only the named actor may update this field.
+     */
+    actorReportedStatus?: Record<string, unknown>;
+}
+interface OrchestrationResourceManifest<TSpec = Record<string, unknown>> extends OrchestrationTypeMeta {
+    metadata: OrchestrationManifestMetadata;
+    spec: TSpec;
+}
+interface OrchestrationResource<TSpec = Record<string, unknown>, TStatus = OrchestrationResourceStatus> extends OrchestrationTypeMeta {
+    metadata: OrchestrationObjectMetadata;
+    spec: TSpec;
+    status?: TStatus;
+}
+interface OrchestrationResourceReference extends OrchestrationTypeMeta {
+    name?: string;
+    namespace?: string;
+    uid?: string;
+}
+interface OrchestrationResourceQuery {
+    apiVersion?: string;
+    kind: string;
+    namespace?: string;
+    labels?: Record<string, string>;
+}
+type OrchestrationEventSeverity = 'Normal' | 'Warning';
+interface OrchestrationEvent {
+    eventId: string;
+    involvedObject: OrchestrationResourceReference;
+    severity: OrchestrationEventSeverity;
+    reason: string;
+    message: string;
+    reportingController: string;
+    eventTime: string;
+    action?: string;
+    count?: number;
+}
+interface OrchestrationPreconditions {
+    uid?: string;
+    resourceVersion?: string;
+    generation?: number;
+}
+type AgentOrchestrationOperation = 'apply' | 'get' | 'list' | 'watch' | 'delete';
+type AgentInfrastructureInterface = 'resource' | 'loop-runtime' | 'tool-execution' | 'model-provider' | 'network' | 'storage' | 'credential-broker' | 'artifact' | 'identity-attestation' | 'policy-approval' | 'audit-telemetry';
+interface AgentOrchestrationCapabilities {
+    operations: AgentOrchestrationOperation[];
+    resourceKinds: string[];
+    /**
+     * Optional per-kind operation matrix when `operations` is not a Cartesian
+     * promise for every advertised kind. Hosts should publish this whenever
+     * controller-owned status resources are read-only to a caller.
+     */
+    resourceOperations?: Record<string, AgentOrchestrationOperation[]>;
+    interfaces: AgentInfrastructureInterface[];
+}
+interface OrchestrationApplyOptions {
+    idempotencyKey?: string;
+    fieldManager?: string;
+    force?: boolean;
+    dryRun?: boolean;
+    preconditions?: OrchestrationPreconditions;
+}
+interface OrchestrationGetOptions {
+    resourceVersion?: string;
+}
+interface OrchestrationListOptions {
+    resourceVersion?: string;
+    resourceVersionMatch?: 'exact' | 'not-older-than';
+    limit?: number;
+    continueToken?: string;
+}
+interface OrchestrationResourceList<TSpec = Record<string, unknown>, TStatus = OrchestrationResourceStatus> {
+    items: Array<OrchestrationResource<TSpec, TStatus>>;
+    resourceVersion: string;
+    continueToken?: string;
+}
+type OrchestrationResourceWatchEventType = 'ADDED' | 'MODIFIED' | 'DELETED';
+interface OrchestrationResourceWatchEvent<TSpec = Record<string, unknown>, TStatus = OrchestrationResourceStatus> {
+    type: OrchestrationResourceWatchEventType;
+    resourceVersion: string;
+    resource: OrchestrationResource<TSpec, TStatus>;
+}
+interface OrchestrationBookmarkWatchEvent {
+    type: 'BOOKMARK';
+    resourceVersion: string;
+}
+interface OrchestrationErrorWatchEvent {
+    type: 'ERROR';
+    resourceVersion: string;
+    terminal: boolean;
+    error: OrchestrationErrorData;
+}
+type OrchestrationWatchEvent<TSpec = Record<string, unknown>, TStatus = OrchestrationResourceStatus> = OrchestrationResourceWatchEvent<TSpec, TStatus> | OrchestrationBookmarkWatchEvent | OrchestrationErrorWatchEvent;
+interface OrchestrationWatchOptions {
+    resourceVersion?: string;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+    allowBookmarks?: boolean;
+    sendInitialEvents?: boolean;
+}
+interface OrchestrationDeleteOptions {
+    idempotencyKey?: string;
+    preconditions?: OrchestrationPreconditions;
+    propagationPolicy?: 'orphan' | 'background' | 'foreground';
+    dryRun?: boolean;
+}
+interface OrchestrationDeleteResult {
+    accepted: boolean;
+    reference: OrchestrationResourceReference;
+}
+/**
+ * Policy-scoped facade exposed to Agent loops and Agent-facing tools.
+ *
+ * Hosts bind actor identity, admission, quotas, and grants when constructing the
+ * facade. Callers receive declarative resource operations only, never raw
+ * infrastructure drivers, platform handles, or credentials.
+ */
+interface AgentOrchestrationClient {
+    getCapabilities(): Promise<AgentOrchestrationCapabilities>;
+    apply<TSpec = Record<string, unknown>, TStatus = OrchestrationResourceStatus>(resource: OrchestrationResourceManifest<TSpec>, options?: OrchestrationApplyOptions): Promise<OrchestrationResource<TSpec, TStatus>>;
+    get<TSpec = Record<string, unknown>, TStatus = OrchestrationResourceStatus>(reference: OrchestrationResourceReference, options?: OrchestrationGetOptions): Promise<OrchestrationResource<TSpec, TStatus> | null>;
+    list<TSpec = Record<string, unknown>, TStatus = OrchestrationResourceStatus>(query: OrchestrationResourceQuery, options?: OrchestrationListOptions): Promise<OrchestrationResourceList<TSpec, TStatus>>;
+    watch<TSpec = Record<string, unknown>, TStatus = OrchestrationResourceStatus>(query: OrchestrationResourceQuery, options?: OrchestrationWatchOptions): AsyncIterable<OrchestrationWatchEvent<TSpec, TStatus>>;
+    delete(reference: OrchestrationResourceReference, options?: OrchestrationDeleteOptions): Promise<OrchestrationDeleteResult>;
+}
+
+interface PromptNode {
+    id: string;
+    text?: string;
+    /** TidGi IPrompt 兼容 */
+    caption?: string;
+    role?: 'system' | 'user' | 'assistant' | 'tool';
+    enabled?: boolean;
+    children?: PromptNode[];
+    /** UI 溯源，可选 */
+    source?: unknown;
+    /**
+     * 与插件 `dynamicPosition` 配合：用户轮次 ≥2 时将根级该节点移到列表末尾。
+     */
+    dynamicPosition?: 'deferToEnd';
+}
+/** 与 TidGi `IPrompt` 对齐的别名 */
+type IPrompt = PromptNode;
+interface PromptPluginConfig {
+    id: string;
+    toolId: string;
+    enabled?: boolean;
+    /** defineTool：`approval`（mode / allowPatterns / denyPatterns）等，类型见 `tools/types` */
+    [key: string]: unknown;
+}
+interface AgentFrameworkConfig {
+    prompts: PromptNode[];
+    response?: unknown[];
+    plugins: PromptPluginConfig[];
+}
+interface AgentPromptDescription {
+    agentFrameworkConfig?: AgentFrameworkConfig;
+}
+
+interface AgentDefinitionModelConfig {
+    provider?: string;
+    model?: string;
+    temperature?: number;
+    maxTokens?: number;
+}
+interface ModelSelection {
+    provider: string;
+    model: string;
+    [key: string]: unknown;
+}
+interface ModelParameters {
+    temperature?: number;
+    maxTokens?: number;
+    topP?: number;
+    [key: string]: unknown;
+}
+interface AiAPIConfig {
+    default?: ModelSelection;
+    embedding?: ModelSelection;
+    speech?: ModelSelection;
+    imageGeneration?: ModelSelection;
+    transcriptions?: ModelSelection;
+    free?: ModelSelection;
+    modelParameters: ModelParameters;
+    [key: string]: unknown;
+}
+interface AgentHeartbeatConfig {
+    enabled: boolean;
+    intervalSeconds: number;
+    message: string;
+    activeHoursStart?: string;
+    activeHoursEnd?: string;
+}
+interface AgentDefinitionToolConfig {
+    toolId: string;
+    enabled?: boolean;
+    parameters?: Record<string, unknown>;
+    tags?: string[];
+}
+type HostAgentToolConfig = AgentDefinitionToolConfig;
+interface AgentDefinition {
+    id: string;
+    name: string;
+    description: string;
+    systemPrompt: string;
+    tools: string[];
+    modelConfig?: AgentDefinitionModelConfig;
+    promptSchema?: unknown;
+    /**
+     * TidGi-Desktop / memeloop：prompt 树、插件、maxIterations 等（结构见 memeloop prompt 类型）
+     * Typed as `AgentFrameworkConfig` so all hosts share a single canonical shape.
+     */
+    agentFrameworkConfig?: AgentFrameworkConfig;
+    /** Host-specific explicit tool configuration. Hosts map this to prompt plugins at runtime. */
+    agentTools?: AgentDefinitionToolConfig[];
+    /** Host-specific avatar or icon URL. */
+    avatarUrl?: string;
+    /** Host-specific agent handler / framework ID. */
+    agentFrameworkID?: string;
+    /** Periodic auto-wake configuration. */
+    heartbeat?: AgentHeartbeatConfig;
+    /** Host-specific AI API config override. */
+    aiApiConfig?: AiAPIConfig;
+    version: string;
+}
+interface AgentInstanceMeta {
+    instanceId: string;
+    definitionId: string;
+    nodeId: string;
+    conversationId: string;
+    createdAt: number;
+    updatedAt: number;
+    definitionDelta?: Partial<AgentDefinition>;
+}
+
+interface AttachmentReference {
+    contentHash: string;
+    filename: string;
+    mimeType: string;
+    size: number;
+}
+type ChatRole = 'user' | 'assistant' | 'tool' | 'agent' | 'error';
+interface ChatTextPart {
+    type: 'text';
+    text: string;
+}
+interface ChatReasoningPart {
+    type: 'reasoning';
+    text: string;
+}
+interface ToolCall {
+    id: string;
+    toolName: string;
+    arguments: unknown;
+}
+interface ChatToolCallPart {
+    type: 'tool-call';
+    toolCallId: string;
+    toolName: string;
+    arguments: unknown;
+}
+/** Points to large tool output stored elsewhere (agent-run log, terminal session, file). */
+type DetailRefType = 'agent-run' | 'terminal-session' | 'file';
+interface DetailReference {
+    type: DetailRefType;
+    /** Delegated agent / spawn / remote conversation id */
+    conversationId?: string;
+    /** Terminal session id (often paired with `terminal:<sessionId>` conversation) */
+    sessionId?: string;
+    /** Node that holds the detail payload */
+    nodeId?: string;
+    /** e.g. `memeloop://node/.../file/...` from `buildMemeloopFileUri` in `../network/uri.js` */
+    fileUri?: string;
+    exitCode?: number;
+}
+interface ChatAttachmentPart {
+    type: 'attachment';
+    attachment: AttachmentReference;
+}
+interface ChatToolResultPart {
+    type: 'tool-result';
+    toolCallId?: string;
+    toolName: string;
+    parameters?: unknown;
+    result: string;
+    isError?: boolean;
+    payload?: unknown;
+    detailRef?: DetailReference;
+}
+type ChatMessagePart = ChatTextPart | ChatReasoningPart | ChatToolCallPart | ChatAttachmentPart | ChatToolResultPart;
+interface ChatMessage {
+    messageId: string;
+    conversationId: string;
+    originNodeId: string;
+    timestamp: number;
+    lamportClock: number;
+    role: ChatRole;
+    /** Canonical structured message payload used for rendering and protocol projection. */
+    parts?: ChatMessagePart[];
+    /** Summary / fallback text projection of `parts` for hosts that only need plain text. */
+    content: string;
+    /** Materialized tool-call projection derived from `parts`. */
+    toolCalls?: ToolCall[];
+    /** Materialized attachment projection derived from `parts`. */
+    attachments?: AttachmentReference[];
+    /** Summary lives in `content`; full payload fetched via detail ref (plan §5.2.1). */
+    detailRef?: DetailReference;
+    /** Materialized reasoning projection derived from `parts`. */
+    reasoning_content?: string;
+    /** Content MIME type */
+    contentType?: string;
+    /** Whether message should be hidden in UI */
+    hidden?: boolean;
+    /** Message processing duration in ms */
+    duration?: number | null;
+    /** Additional metadata */
+    metadata?: Record<string, unknown>;
+}
+
+type IMPlatformType = 'telegram' | 'discord' | 'lark' | 'wecom' | 'slack' | 'line' | 'qq';
+interface IMChannel {
+    channelId: string;
+    platform: IMPlatformType;
+    nodeId: string;
+    webhookMode: 'cloud-relay' | 'direct';
+    webhookUrl?: string;
+    defaultDefinitionId?: string;
+    status: 'active' | 'inactive' | 'error';
+}
+interface IMChannelBinding {
+    channelId: string;
+    imUserId: string;
+    activeConversationId: string;
+    createdAt: number;
+    defaultDefinitionId?: string;
+    /** When set, the user's next inbound message is treated as an askQuestion answer (plan §20.3). */
+    pendingQuestionId?: string;
+}
+/** @deprecated Use IMChannelBinding */
+type ImChannelBindingRecord = IMChannelBinding;
+
+type VersionVector = Record<string, number>;
+interface ConversationMeta {
+    conversationId: string;
+    title: string;
+    lastMessagePreview: string;
+    lastMessageTimestamp: number;
+    messageCount: number;
+    originNodeId: string;
+    definitionId: string;
+    instanceDelta?: Record<string, unknown>;
+    isUserInitiated: boolean;
+    sourceChannel?: {
+        channelId: string;
+        platform: string;
+        imUserId: string;
+    };
+}
+declare function isConversationMeta(value: unknown): value is ConversationMeta;
+
+/**
+ * Narrow logical storage ports (plan 24.41).
+ *
+ * Loop/runtime code depends on these small portable interfaces instead of a
+ * monolithic storage facade. Hosts (CLI SQLite, Desktop repositories, browser
+ * IndexedDB, remote adapters) implement any combination; binary payloads are
+ * `Uint8Array` only, keeping the ports usable in browsers and edge runtimes.
+ */
+type ConversationQueryMode = 'metadata-only' | 'full-content' | 'on-demand';
+interface ListConversationsOptions {
+    limit?: number;
+    offset?: number;
+}
+interface GetMessagesOptions {
+    mode?: ConversationQueryMode;
+}
+/** Append-only conversation event log. */
+interface ConversationEventStore {
+    listConversations(options?: ListConversationsOptions): Promise<ConversationMeta[]>;
+    getMessages(conversationId: string, options?: GetMessagesOptions): Promise<ChatMessage[]>;
+    appendMessage(message: ChatMessage): Promise<void>;
+    /** Merge remote/peer events; refreshes per-conversation messageCount. */
+    insertMessagesIfAbsent(messages: ChatMessage[]): Promise<void>;
+    /** Optional optimization: `SELECT MAX(lamportClock)` instead of scanning. */
+    getMaxLamportClockForConversation?(conversationId: string): Promise<number>;
+}
+/** Conversation directory/metadata rows (sync and peer metadata). */
+interface ConversationDirectoryStore {
+    upsertConversationMetadata(meta: ConversationMeta): Promise<void>;
+    /** Read the conversation metadata row used to resolve `definitionId`. */
+    getConversationMeta(conversationId: string): Promise<ConversationMeta | null>;
+}
+/** Content-addressed binary storage. Bytes are `Uint8Array` on every path. */
+interface BlobStore {
+    getAttachment(contentHash: string): Promise<AttachmentReference | null>;
+    saveAttachment(reference: AttachmentReference, data: Uint8Array): Promise<void>;
+    /** Read persisted attachment bytes (cross-node blob transfer). */
+    readAttachmentData?(contentHash: string): Promise<Uint8Array | null>;
+}
+/** Agent definition lookup. */
+interface DefinitionStore {
+    getAgentDefinition(id: string): Promise<AgentDefinition | null>;
+}
+/** Agent run/instance state. */
+interface AgentInstanceStore {
+    saveAgentInstance(meta: AgentInstanceMeta): Promise<void>;
+}
+/** IM user-to-conversation binding persistence. */
+interface ImBindingStore {
+    getImBinding?(channelId: string, imUserId: string): Promise<IMChannelBinding | null>;
+    setImBinding?(record: IMChannelBinding): Promise<void>;
+}
+/**
+ * Convenience composition for hosts that provide every port (the previous
+ * `IAgentStorage` shape). New consumers should depend on the narrow port they
+ * actually use.
+ */
+interface FullAgentStorage extends ConversationEventStore, ConversationDirectoryStore, BlobStore, DefinitionStore, AgentInstanceStore, ImBindingStore {
+}
+
+/**
+ * Monolithic storage facade (legacy shape: every port combined). Prefer the
+ * narrow ports in `./ports.js` for new code so hosts can implement only the
+ * capabilities they actually have.
+ */
+type IAgentStorage = FullAgentStorage;
+
+export { type AgentOrchestrationCapabilities as $, type AttachmentReference as A, type OrchestrationGetOptions as B, type ConversationMeta as C, type DetailRefType as D, type OrchestrationResource as E, type OrchestrationResourceQuery as F, type GetMessagesOptions as G, type HostAgentToolConfig as H, type IAgentStorage as I, type OrchestrationListOptions as J, type OrchestrationResourceList as K, type ListConversationsOptions as L, type ModelParameters as M, type OrchestrationWatchOptions as N, type OrchestrationErrorData as O, type OrchestrationWatchEvent as P, type OrchestrationDeleteOptions as Q, type OrchestrationDeleteResult as R, type AgentFrameworkConfig as S, type ToolCall as T, type IPrompt as U, type VersionVector as V, type PromptNode as W, type AgentPromptDescription as X, type FullAgentStorage as Y, type AgentInfrastructureInterface as Z, type AgentInstanceStore as _, type ChatAttachmentPart as a, type AgentOrchestrationOperation as a0, type BlobStore as a1, type ConversationDirectoryStore as a2, type DefinitionStore as a3, type IMChannel as a4, type IMChannelBinding as a5, type IMPlatformType as a6, type ImBindingStore as a7, type ImChannelBindingRecord as a8, ORCHESTRATION_ERROR_CODES as a9, type OrchestrationApplyOptions as aa, type OrchestrationBookmarkWatchEvent as ab, type OrchestrationCondition as ac, type OrchestrationConditionStatus as ad, OrchestrationError as ae, type OrchestrationErrorCode as af, type OrchestrationErrorWatchEvent as ag, type OrchestrationEvent as ah, type OrchestrationEventSeverity as ai, type OrchestrationManifestMetadata as aj, type OrchestrationPreconditions as ak, type OrchestrationResourceWatchEvent as al, type OrchestrationResourceWatchEventType as am, type PromptPluginConfig as an, isOrchestrationError as ao, toOrchestrationErrorData as ap, type ChatMessage as b, type ChatMessagePart as c, type ChatReasoningPart as d, type ChatRole as e, type ChatTextPart as f, type ChatToolCallPart as g, type ChatToolResultPart as h, isConversationMeta as i, type ConversationQueryMode as j, type DetailReference as k, type ConversationEventStore as l, type AgentDefinition as m, type AgentDefinitionModelConfig as n, type AgentDefinitionToolConfig as o, type AgentHeartbeatConfig as p, type AgentInstanceMeta as q, type AiAPIConfig as r, type ModelSelection as s, type AgentOrchestrationClient as t, type OrchestrationResourceManifest as u, type OrchestrationOwnerReference as v, type OrchestrationTypeMeta as w, type OrchestrationObjectMetadata as x, type OrchestrationResourceStatus as y, type OrchestrationResourceReference as z };

package/dist/llm-providers.cjs

@@ -54,27 +54,60 @@ var import_ai = require("ai");
 function createFetchLLMProvider(config) {
   return {
     name: config.name,
+    ...config.modelId !== void 0 ? { modelId: config.modelId } : {},
     // Store the factory so hosts can introspect or extend
     model: config.createModel,
     async chat(request) {
       const body = typeof request === "object" && request !== null ? request : {};
       const model = config.createModel(body.model);
-      const messages = (body.messages ?? []).map((message) => ({
-        role: message.role,
-        content: message.content
-      }));
-      const system = body.system;
+      const specificationVersion = model?.specificationVersion;
+      if (model === null || typeof model !== "object" || !["v2", "v3", "v4"].includes(String(specificationVersion))) {
+        throw new Error(
+          `LLM provider '${config.name}' returned an incompatible AI SDK model for '${typeof body.model === "string" ? body.model : config.modelId ?? "default"}' (expected specificationVersion v2, v3, or v4; received ${String(specificationVersion)})`
+        );
+      }
+      const systemMessages = (body.messages ?? []).filter((message) => message.role === "system").map((message) => message.content);
+      const messages = (body.messages ?? []).filter((message) => message.role !== "system").map((message) => {
+        const role = message.role === "tool" ? "user" : message.role;
+        return {
+          role,
+          content: message.content
+        };
+      });
+      const system = body.system ?? (systemMessages.length > 0 ? systemMessages.join("\n\n") : void 0);
       const temperature = body.temperature;
       const abortSignal = body.abortSignal;
+      const maxOutputTokens = body.max_tokens;
       if (body.stream !== false) {
-        const result2 = (0, import_ai.streamText)({ model, system, messages, temperature, abortSignal });
+        let streamingError;
+        const result2 = (0, import_ai.streamText)({
+          model,
+          instructions: system,
+          messages,
+          maxOutputTokens,
+          temperature,
+          abortSignal,
+          onError: ({ error }) => {
+            streamingError = error;
+          }
+        });
         return (async function* () {
           for await (const chunk of result2.textStream) {
             yield chunk;
           }
+          if (streamingError !== void 0) {
+            throw streamingError instanceof Error ? streamingError : new Error("The model stream failed", { cause: streamingError });
+          }
         })();
       }
-      const result = await (0, import_ai.generateText)({ model, system, messages, temperature, abortSignal });
+      const result = await (0, import_ai.generateText)({
+        model,
+        instructions: system,
+        messages,
+        maxOutputTokens,
+        temperature,
+        abortSignal
+      });
       return result.text;
     }
   };
@@ -102,7 +135,7 @@ async function loadProviderFactory(provider) {
       const { createOpenAI } = await import("@ai-sdk/openai");
       return (apiKey, baseUrl, options) => {
         const sdk = createOpenAI({ apiKey, baseURL: baseUrl, ...options });
-        return (modelId) => sdk(modelId);
+        return (modelId) => sdk.chat(modelId);
       };
     }
     case "anthropic": {
@@ -204,6 +237,7 @@ async function createLLMProvider(config) {
   const modelFactory = createProviderModel(config.apiKey, config.baseUrl, config.options);
   return createFetchLLMProvider({
     name,
+    modelId: resolveModel(),
     createModel: (modelId) => modelFactory(resolveModel(modelId))
   });
 }
@@ -221,6 +255,7 @@ async function createOpenAICompatibleProvider(config) {
   });
   return createFetchLLMProvider({
     name,
+    modelId: resolveModel(),
     createModel: (modelId) => sdk(resolveModel(modelId))
   });
 }