@yushaw/sanqian-ai-sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,2117 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  EMPTY_CAPABILITIES: () => EMPTY_CAPABILITIES,
+  MockSanqianSdk: () => MockSanqianSdk,
+  SanqianEmbeddingProvider: () => SanqianEmbeddingProvider,
+  SanqianProvider: () => SanqianProvider,
+  SanqianRerankProvider: () => SanqianRerankProvider,
+  VercelEmbeddingProvider: () => VercelEmbeddingProvider,
+  VercelProvider: () => VercelProvider,
+  convertSdkStreamEvent: () => convertSdkStreamEvent,
+  convertToolsForVercel: () => convertToolsForVercel,
+  createActiveWorkTracker: () => createActiveWorkTracker,
+  createCategoryPermissionPolicy: () => createCategoryPermissionPolicy,
+  createChatRuntimeBridge: () => createChatRuntimeBridge,
+  createDefaultPermissionPolicy: () => createDefaultPermissionPolicy,
+  createDisabledState: () => createDisabledState,
+  createEmbeddingSession: () => createEmbeddingSession,
+  createMemoryConversationStore: () => createMemoryConversationStore,
+  createMemorySecretStore: () => createMemorySecretStore,
+  createOutputOperationsManager: () => createOutputOperationsManager,
+  createPermissionGate: () => createPermissionGate,
+  createSanqianAgentIdResolver: () => createSanqianAgentIdResolver,
+  createSessionManager: () => createSessionManager,
+  createTaskPipeline: () => createTaskPipeline,
+  createToolRegistry: () => createToolRegistry,
+  redactToolError: () => redactToolError,
+  resolveAiFeaturesFromRuntime: () => resolveAiFeaturesFromRuntime,
+  validateOutputContent: () => validateOutputContent
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/contracts/tools.ts
+function createToolRegistry() {
+  const tools = /* @__PURE__ */ new Map();
+  return {
+    register(definition, handler, metadata) {
+      tools.set(definition.name, {
+        definition,
+        handler,
+        metadata: {
+          category: metadata?.category ?? "read-only",
+          readOnlyHint: metadata?.readOnlyHint,
+          destructiveHint: metadata?.destructiveHint,
+          idempotentHint: metadata?.idempotentHint
+        }
+      });
+    },
+    get(name) {
+      return tools.get(name);
+    },
+    list() {
+      return Array.from(tools.values());
+    },
+    async execute(input) {
+      const registration = tools.get(input.name);
+      if (!registration) {
+        return {
+          toolCallId: input.toolCallId,
+          success: false,
+          error: `Unknown tool: ${input.name}`
+        };
+      }
+      try {
+        const result = await registration.handler(input.args, {
+          toolCallId: input.toolCallId,
+          signal: input.signal
+        });
+        return {
+          toolCallId: input.toolCallId,
+          result,
+          success: true
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Tool execution failed";
+        return {
+          toolCallId: input.toolCallId,
+          success: false,
+          error: message
+        };
+      }
+    }
+  };
+}
+
+// src/contracts/permissions.ts
+function createPermissionGate(policy) {
+  const pending = /* @__PURE__ */ new Map();
+  const listeners = /* @__PURE__ */ new Set();
+  let counter = 0;
+  return {
+    async requestPermission(input) {
+      const decision = await policy.evaluate(input);
+      if (decision.type !== "ask") {
+        return decision;
+      }
+      return new Promise((resolve) => {
+        counter++;
+        const id = `perm-${counter}`;
+        const entry = {
+          id,
+          toolCallId: input.toolCallId,
+          toolName: input.name,
+          args: input.args,
+          createdAt: Date.now(),
+          resolve: (userDecision) => {
+            pending.delete(id);
+            if (userDecision === "approve") {
+              resolve({ type: "allow" });
+            } else if (userDecision === "deny") {
+              resolve({ type: "deny", reason: "User denied" });
+            } else {
+              resolve({ type: "deny", reason: "Cancelled" });
+            }
+          }
+        };
+        pending.set(id, entry);
+        for (const listener of listeners) {
+          listener(entry);
+        }
+      });
+    },
+    resolvePermission(id, decision) {
+      const entry = pending.get(id);
+      if (entry) {
+        entry.resolve(decision);
+      }
+    },
+    cancelAll() {
+      for (const entry of pending.values()) {
+        entry.resolve("cancel");
+      }
+      pending.clear();
+    },
+    listPending() {
+      return Array.from(pending.values());
+    },
+    onPermissionRequest(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    }
+  };
+}
+function createDefaultPermissionPolicy() {
+  return {
+    async evaluate() {
+      return { type: "allow" };
+    }
+  };
+}
+function createCategoryPermissionPolicy(registry) {
+  const mutationCategories = [
+    "note-mutation",
+    "notebook-mutation",
+    "local-file-write",
+    "dangerous"
+  ];
+  return {
+    async evaluate(input) {
+      const tool = registry.get(input.name);
+      if (!tool) {
+        return { type: "deny", reason: `Unknown tool: ${input.name}` };
+      }
+      if (mutationCategories.includes(tool.metadata.category)) {
+        return {
+          type: "ask",
+          interrupt: {
+            type: "approval_request",
+            payload: {
+              tool: input.name,
+              args: input.args,
+              reason: `Tool "${input.name}" requires approval (category: ${tool.metadata.category})`
+            }
+          }
+        };
+      }
+      return { type: "allow" };
+    }
+  };
+}
+function redactToolError(error) {
+  let redacted = error;
+  redacted = redacted.replace(/\n\s+at\s+.+/g, "");
+  redacted = redacted.replace(/(?:\/[\w.@-]+){2,}/g, "[path]");
+  redacted = redacted.replace(/[A-Z]:\\[\w.\\-]+/g, "[path]");
+  redacted = redacted.replace(/SQLITE_\w+|sqlite3?_\w+/gi, "[db-error]");
+  return redacted.trim();
+}
+
+// src/contracts/conversations.ts
+function createMemoryConversationStore() {
+  const conversations = /* @__PURE__ */ new Map();
+  let counter = 0;
+  return {
+    async list(input) {
+      let items = Array.from(conversations.values());
+      if (input.providerId) {
+        items = items.filter((c) => c.providerId === input.providerId);
+      }
+      if (input.agentId) {
+        items = items.filter((c) => c.agentId === input.agentId);
+      }
+      items.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+      const offset = input.offset ?? 0;
+      const limit = input.limit ?? 20;
+      return {
+        conversations: items.slice(offset, offset + limit),
+        total: items.length
+      };
+    },
+    async get(id, input) {
+      const conv = conversations.get(id);
+      if (!conv) return null;
+      if (input?.messageLimit) {
+        return {
+          ...conv,
+          messages: conv.messages.slice(-input.messageLimit)
+        };
+      }
+      return conv;
+    },
+    async create(input) {
+      counter++;
+      const id = `conv-${counter}`;
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const detail = {
+        id,
+        providerId: input.providerId,
+        agentId: input.agentId,
+        title: input.title ?? "Untitled",
+        createdAt: now,
+        updatedAt: now,
+        messageCount: 0,
+        messages: []
+      };
+      conversations.set(id, detail);
+      return detail;
+    },
+    async appendMessages(id, messages) {
+      const conv = conversations.get(id);
+      if (!conv) throw new Error(`Conversation not found: ${id}`);
+      conv.messages.push(...messages);
+      conv.messageCount = conv.messages.length;
+      conv.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    },
+    async update(id, patch) {
+      const conv = conversations.get(id);
+      if (!conv) throw new Error(`Conversation not found: ${id}`);
+      if (patch.title !== void 0) conv.title = patch.title;
+      conv.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    },
+    async delete(id) {
+      conversations.delete(id);
+    }
+  };
+}
+
+// src/contracts/active-work.ts
+function createActiveWorkTracker() {
+  const works = /* @__PURE__ */ new Map();
+  return {
+    register(work) {
+      works.set(work.id, work);
+    },
+    unregister(id) {
+      works.delete(id);
+    },
+    list() {
+      return Array.from(works.values());
+    },
+    listByProvider(providerId) {
+      return Array.from(works.values()).filter((w) => w.providerId === providerId);
+    },
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async cancelAll(_reason) {
+      for (const work of works.values()) {
+        work.abort();
+      }
+      works.clear();
+    },
+    async cancelByProvider(providerId) {
+      for (const [id, work] of works.entries()) {
+        if (work.providerId === providerId) {
+          work.abort();
+          works.delete(id);
+        }
+      }
+    }
+  };
+}
+
+// src/contracts/readiness.ts
+var EMPTY_CAPABILITIES = {
+  streamingText: false,
+  reasoning: false,
+  toolCalling: false,
+  parallelToolCalls: false,
+  toolArgsStreaming: false,
+  abort: false,
+  hitl: false,
+  conversations: false,
+  sessionResources: false,
+  resourcePicker: false,
+  embeddings: false,
+  rerank: false
+};
+function createDisabledState() {
+  return {
+    enabled: false,
+    activeProviderId: null,
+    activeProviderKind: null,
+    ready: false,
+    capabilities: { ...EMPTY_CAPABILITIES },
+    source: "manual-disabled"
+  };
+}
+
+// src/contracts/secrets.ts
+function createMemorySecretStore() {
+  const secrets = /* @__PURE__ */ new Map();
+  let counter = 0;
+  return {
+    async put(input) {
+      counter++;
+      const id = `secret-${counter}`;
+      const ref = { id, providerInstanceId: input.providerInstanceId };
+      const now = Date.now();
+      secrets.set(id, {
+        value: input.value,
+        descriptor: {
+          id,
+          providerInstanceId: input.providerInstanceId,
+          label: input.label,
+          maskedValue: input.value.slice(0, 4) + "****",
+          createdAt: now,
+          updatedAt: now
+        }
+      });
+      return ref;
+    },
+    async get(ref) {
+      const entry = secrets.get(ref.id);
+      if (!entry) throw new Error(`Secret not found: ${ref.id}`);
+      return entry.value;
+    },
+    async delete(ref) {
+      secrets.delete(ref.id);
+    },
+    async describe(ref) {
+      const entry = secrets.get(ref.id);
+      if (!entry) throw new Error(`Secret not found: ${ref.id}`);
+      return entry.descriptor;
+    }
+  };
+}
+
+// src/contracts/session.ts
+function createSessionManager(workTracker) {
+  let activeProvider = null;
+  const listeners = /* @__PURE__ */ new Set();
+  function emit(event) {
+    for (const listener of listeners) {
+      listener(event);
+    }
+  }
+  return {
+    getActiveProvider() {
+      return activeProvider;
+    },
+    getActiveDescriptor() {
+      if (!activeProvider) return null;
+      return {
+        id: activeProvider.id,
+        kind: activeProvider.kind,
+        displayName: activeProvider.displayName,
+        capabilities: activeProvider.capabilities
+      };
+    },
+    getRuntimeState() {
+      if (!activeProvider) return createDisabledState();
+      return {
+        enabled: true,
+        activeProviderId: activeProvider.id,
+        activeProviderKind: activeProvider.kind,
+        ready: true,
+        capabilities: activeProvider.capabilities,
+        source: "runtime-provider"
+      };
+    },
+    async switchProvider(config, options) {
+      const previousId = activeProvider?.id ?? null;
+      if (options?.ifBusy === "cancel-active-work") {
+        await workTracker.cancelAll("provider-switch");
+      }
+      try {
+        await config.provider.ensureReady();
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Provider readiness failed";
+        return {
+          success: false,
+          previousProviderId: previousId ?? void 0,
+          error: message
+        };
+      }
+      const oldProvider = activeProvider;
+      activeProvider = config.provider;
+      if (oldProvider?.dispose) {
+        try {
+          await oldProvider.dispose();
+        } catch {
+        }
+      }
+      emit({
+        previousProviderId: previousId,
+        newProviderId: config.provider.id,
+        capabilities: config.provider.capabilities
+      });
+      return {
+        success: true,
+        previousProviderId: previousId ?? void 0,
+        newProviderId: config.provider.id
+      };
+    },
+    async cancelAll(reason) {
+      await workTracker.cancelAll(reason);
+    },
+    onProviderChanged(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    }
+  };
+}
+
+// src/contracts/task-pipeline.ts
+function createTaskPipeline(getProvider) {
+  let formatterQueue = Promise.resolve();
+  return {
+    async *executeWithFormatter(input) {
+      const provider = getProvider();
+      if (!provider) {
+        yield { type: "error", error: "No active provider" };
+        return;
+      }
+      yield { type: "start" };
+      let resultText = "";
+      const contentStream = provider.chatStream({
+        agentId: input.contentAgentId,
+        messages: input.contentMessages,
+        signal: input.signal
+      });
+      for await (const event of contentStream) {
+        if (input.signal?.aborted) {
+          yield { type: "cancelled" };
+          return;
+        }
+        if (event.type === "text") {
+          resultText += event.content;
+        }
+        if (event.type === "error") {
+          yield event;
+          return;
+        }
+        yield event;
+      }
+      if (!resultText || input.signal?.aborted) {
+        if (input.signal?.aborted) {
+          yield { type: "cancelled" };
+        }
+        return;
+      }
+      const previousQueue = formatterQueue;
+      let releaseSlotFn;
+      const currentSlot = new Promise((resolve) => {
+        releaseSlotFn = resolve;
+      });
+      formatterQueue = previousQueue.catch(() => void 0).then(() => currentSlot);
+      await previousQueue.catch(() => void 0);
+      try {
+        if (input.signal?.aborted) {
+          yield { type: "cancelled" };
+          return;
+        }
+        const formatterPrompt = buildFormatterPrompt(
+          input.contentMessages[input.contentMessages.length - 1]?.content ?? "",
+          resultText,
+          input.outputFormat
+        );
+        const formatterStream = provider.chatStream({
+          agentId: input.formatterConfig.id,
+          messages: [
+            { role: "system", content: input.formatterConfig.systemPrompt },
+            { role: "user", content: formatterPrompt }
+          ],
+          tools: input.outputTools,
+          signal: input.signal
+        });
+        for await (const event of formatterStream) {
+          if (input.signal?.aborted) {
+            yield { type: "cancelled" };
+            return;
+          }
+          yield event;
+        }
+        yield { type: "done", conversationId: "" };
+      } finally {
+        releaseSlotFn?.();
+      }
+    }
+  };
+}
+function buildFormatterPrompt(userRequest, content, outputFormat) {
+  let request = userRequest;
+  if (outputFormat && outputFormat !== "auto") {
+    const formatMap = {
+      paragraph: "paragraph format",
+      list: "list format",
+      table: "table format",
+      code: "code block format",
+      quote: "blockquote format"
+    };
+    const hint = formatMap[outputFormat] ?? outputFormat;
+    request = request ? `${request} (use ${hint})` : `Use ${hint}`;
+  }
+  return `<user_request>
+${request || "No specific request"}
+</user_request>
+
+<original_content>
+${content}
+</original_content>`;
+}
+
+// src/contracts/embedding.ts
+function createEmbeddingSession() {
+  let embeddingProvider = null;
+  let rerankProvider = null;
+  const listeners = /* @__PURE__ */ new Set();
+  function emit(event) {
+    for (const listener of listeners) {
+      listener(event);
+    }
+  }
+  return {
+    getEmbeddingProvider() {
+      return embeddingProvider;
+    },
+    getRerankProvider() {
+      return rerankProvider;
+    },
+    async setEmbeddingProvider(provider) {
+      const prev = embeddingProvider;
+      await provider.ensureReady();
+      const modelChanged = !prev || prev.model !== provider.model || prev.dimensions !== provider.dimensions;
+      if (prev?.dispose) {
+        await prev.dispose().catch(() => {
+        });
+      }
+      embeddingProvider = provider;
+      if (modelChanged) {
+        const event = {
+          previousModel: prev?.model ?? null,
+          previousDimensions: prev?.dimensions ?? null,
+          newModel: provider.model,
+          newDimensions: provider.dimensions
+        };
+        emit(event);
+        return event;
+      }
+      return null;
+    },
+    async setRerankProvider(provider) {
+      const prev = rerankProvider;
+      await provider.ensureReady();
+      if (prev?.dispose) {
+        await prev.dispose().catch(() => {
+        });
+      }
+      rerankProvider = provider;
+    },
+    async clearEmbeddingProvider() {
+      const prev = embeddingProvider;
+      if (!prev) return null;
+      if (prev.dispose) {
+        await prev.dispose().catch(() => {
+        });
+      }
+      embeddingProvider = null;
+      const event = {
+        previousModel: prev.model,
+        previousDimensions: prev.dimensions,
+        newModel: "",
+        newDimensions: 0
+      };
+      emit(event);
+      return event;
+    },
+    async clearRerankProvider() {
+      const prev = rerankProvider;
+      if (prev?.dispose) {
+        await prev.dispose().catch(() => {
+        });
+      }
+      rerankProvider = null;
+    },
+    onModelChange(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    }
+  };
+}
+
+// src/contracts/bridge.ts
+function resolveAiFeaturesFromRuntime(preference, runtimeState, sanqianInstalled) {
+  if (preference === "enabled") return true;
+  if (preference === "disabled") return false;
+  return runtimeState.ready || sanqianInstalled;
+}
+
+// src/contracts/bridge-impl.ts
+function createChatRuntimeBridge(config) {
+  const { sessionManager, conversationStore, permissionGate } = config;
+  const activeStreams = /* @__PURE__ */ new Map();
+  return {
+    getActiveStreams() {
+      return activeStreams;
+    },
+    async ensureReady() {
+      const provider = sessionManager.getActiveProvider();
+      if (!provider) throw new Error("No active provider");
+      await provider.ensureReady();
+    },
+    isConnected() {
+      return sessionManager.getActiveProvider() !== null;
+    },
+    getRuntimeState() {
+      return sessionManager.getRuntimeState();
+    },
+    getCapabilities() {
+      const provider = sessionManager.getActiveProvider();
+      return provider?.capabilities ?? EMPTY_CAPABILITIES;
+    },
+    async *chatStream(input) {
+      const provider = sessionManager.getActiveProvider();
+      if (!provider) {
+        yield { type: "error", error: "No active provider" };
+        return;
+      }
+      const streamId = `stream-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+      const abortController = new AbortController();
+      const streamEntry = {
+        streamId,
+        runId: null,
+        abortController,
+        cancelled: false
+      };
+      activeStreams.set(streamId, streamEntry);
+      if (input.signal) {
+        input.signal.addEventListener("abort", () => {
+          streamEntry.cancelled = true;
+          abortController.abort();
+        }, { once: true });
+      }
+      try {
+        const stream = provider.chatStream({
+          ...input,
+          signal: abortController.signal
+        });
+        for await (const event of stream) {
+          if (streamEntry.cancelled) {
+            yield { type: "cancelled", runId: streamEntry.runId ?? void 0 };
+            return;
+          }
+          if (event.type === "start" && "runId" in event && event.runId) {
+            streamEntry.runId = event.runId;
+          }
+          yield event;
+        }
+      } catch (error) {
+        if (!streamEntry.cancelled) {
+          yield { type: "error", error: error instanceof Error ? error.message : "Stream error" };
+        }
+      } finally {
+        activeStreams.delete(streamId);
+      }
+    },
+    async cancelStream(input) {
+      if (input?.streamId) {
+        const stream = activeStreams.get(input.streamId);
+        if (stream) {
+          stream.cancelled = true;
+          stream.abortController.abort();
+          const provider = sessionManager.getActiveProvider();
+          if (provider?.cancel && stream.runId) {
+            await provider.cancel(stream.runId);
+          }
+          return;
+        }
+      }
+      if (input?.runId) {
+        const provider = sessionManager.getActiveProvider();
+        if (provider?.cancel) {
+          await provider.cancel(input.runId);
+        }
+        for (const stream of activeStreams.values()) {
+          if (stream.runId === input.runId) {
+            stream.cancelled = true;
+            stream.abortController.abort();
+            break;
+          }
+        }
+      }
+    },
+    async sendPermissionResponse(input) {
+      if (permissionGate) {
+        permissionGate.resolvePermission(input.runId, input.decision);
+        return;
+      }
+      const provider = sessionManager.getActiveProvider();
+      if (provider?.sendPermissionResponse) {
+        await provider.sendPermissionResponse(input);
+      }
+    },
+    async listConversations(input) {
+      return conversationStore.list(input);
+    },
+    async getConversation(id, input) {
+      return conversationStore.get(id, input);
+    },
+    async deleteConversation(id) {
+      return conversationStore.delete(id);
+    }
+    // Resource picker -- capability-gated, not implemented for non-Sanqian
+    // These methods are optional on ChatRuntimeBridge
+  };
+}
+
+// src/contracts/output-operations.ts
+function validateOutputContent(type, content) {
+  if (content === null || content === void 0 || typeof content !== "object") {
+    return `${type}: content must be an object`;
+  }
+  const c = content;
+  switch (type) {
+    case "paragraph":
+      if (!Array.isArray(c.paragraphs)) return "paragraph: paragraphs must be an array";
+      break;
+    case "list":
+      if (!Array.isArray(c.items)) return "list: items must be an array";
+      break;
+    case "table":
+      if (!Array.isArray(c.headers)) return "table: headers must be an array";
+      if (!Array.isArray(c.rows)) return "table: rows must be an array";
+      break;
+    case "heading":
+      if (typeof c.text !== "string") return "heading: text must be a string";
+      break;
+    case "codeBlock":
+      if (typeof c.code !== "string") return "codeBlock: code must be a string";
+      break;
+    case "blockquote":
+      if (typeof c.text !== "string") return "blockquote: text must be a string";
+      break;
+    case "html":
+      if (typeof c.html !== "string") return "html: html must be a string";
+      break;
+    case "noteRef":
+      if (typeof c.noteTitle !== "string") return "noteRef: noteTitle must be a string";
+      break;
+  }
+  return null;
+}
+function createOutputOperationsManager() {
+  const pending = /* @__PURE__ */ new Map();
+  return {
+    initTaskOutput(taskId, context) {
+      pending.set(taskId, { context, operations: [] });
+    },
+    queueOp(taskId, type, content) {
+      const entry = pending.get(taskId);
+      if (!entry) {
+        return { success: false, error: "No pending context for task" };
+      }
+      const validationError = validateOutputContent(type, content);
+      if (validationError) {
+        return { success: false, error: validationError };
+      }
+      entry.operations.push({ type, content });
+      return { success: true };
+    },
+    getTaskOutput(taskId) {
+      return pending.get(taskId) ?? null;
+    },
+    commitTaskOutput(taskId) {
+      const entry = pending.get(taskId);
+      if (!entry || entry.operations.length === 0) {
+        pending.delete(taskId);
+        return null;
+      }
+      const data = {
+        taskId,
+        context: entry.context,
+        operations: [...entry.operations]
+      };
+      pending.delete(taskId);
+      return data;
+    },
+    clearTaskOutput(taskId) {
+      pending.delete(taskId);
+    }
+  };
+}
+
+// src/providers/sanqian/event-converter.ts
+function convertSdkStreamEvent(event) {
+  switch (event.type) {
+    case "start":
+      return {
+        type: "start",
+        runId: event.run_id,
+        conversationId: event.conversationId
+      };
+    case "text":
+      return {
+        type: "text",
+        content: event.content ?? ""
+      };
+    case "thinking":
+      return {
+        type: "thinking",
+        content: event.content ?? ""
+      };
+    case "tool_call":
+      if (!event.tool_call) return null;
+      return {
+        type: "tool_call",
+        toolCall: {
+          id: event.tool_call.id,
+          name: event.tool_call.function.name,
+          arguments: event.tool_call.function.arguments
+        }
+      };
+    case "tool_args_chunk":
+      return {
+        type: "tool_args_chunk",
+        toolCallId: event.tool_call_id ?? "",
+        toolName: event.tool_name ?? "",
+        chunk: event.chunk ?? ""
+      };
+    case "tool_args":
+      return {
+        type: "tool_args",
+        toolCallId: event.tool_call_id ?? "",
+        toolName: event.tool_name ?? "",
+        args: event.args ?? {}
+      };
+    case "tool_result":
+      return {
+        type: "tool_result",
+        toolCallId: event.tool_call_id ?? "",
+        result: event.result,
+        success: event.success,
+        error: event.error,
+        status: event.status,
+        actionRequired: event.action_required,
+        settingsTab: event.settings_tab,
+        settingsSubTab: event.settings_sub_tab,
+        commandExitCode: event.command_exit_code,
+        durationMs: event.duration_ms,
+        sandboxed: event.sandboxed,
+        timedOut: event.timed_out,
+        truncated: event.truncated,
+        stdoutPath: event.stdout_path,
+        stderrPath: event.stderr_path,
+        presentation: event.presentation
+      };
+    case "done":
+      return {
+        type: "done",
+        conversationId: event.conversationId ?? "",
+        title: event.title
+      };
+    case "error":
+      return {
+        type: "error",
+        error: event.error ?? "Unknown error"
+      };
+    case "cancelled":
+      return {
+        type: "cancelled",
+        runId: event.run_id
+      };
+    case "interrupt":
+      return {
+        type: "interrupt",
+        runId: event.run_id,
+        interrupt: {
+          type: event.interrupt_type ?? "",
+          payload: event.interrupt_payload
+        }
+      };
+    default:
+      return null;
+  }
+}
+
+// src/providers/sanqian/agent-id-resolver.ts
+function createSanqianAgentIdResolver(appName) {
+  const mappings = /* @__PURE__ */ new Map();
+  const reverseMappings = /* @__PURE__ */ new Map();
+  const prefix = `${appName}:`;
+  return {
+    setMapping(shortId, registeredId) {
+      mappings.set(shortId, registeredId);
+      reverseMappings.set(registeredId, shortId);
+    },
+    clearMappings() {
+      mappings.clear();
+      reverseMappings.clear();
+    },
+    toRuntimeAgentId(input) {
+      if (!input.includes(":")) return input;
+      const short = reverseMappings.get(input);
+      if (short) return short;
+      if (input.startsWith(prefix)) {
+        return input.slice(prefix.length);
+      }
+      return input;
+    },
+    async toProviderAgentId(shortId) {
+      const registered = mappings.get(shortId);
+      if (registered) return registered;
+      if (shortId.includes(":")) return shortId;
+      return `${prefix}${shortId}`;
+    },
+    isProviderManagedId(input) {
+      return input.includes(":");
+    }
+  };
+}
+
+// src/providers/sanqian/provider.ts
+var SANQIAN_CAPABILITIES = {
+  streamingText: true,
+  reasoning: true,
+  toolCalling: true,
+  parallelToolCalls: true,
+  toolArgsStreaming: true,
+  abort: true,
+  hitl: true,
+  conversations: true,
+  sessionResources: true,
+  resourcePicker: true,
+  embeddings: true,
+  rerank: true
+};
+var SanqianProvider = class {
+  id;
+  kind = "sanqian-sdk";
+  displayName;
+  capabilities = SANQIAN_CAPABILITIES;
+  sdk;
+  appName;
+  agentConfigs;
+  agentIdResolver;
+  disposed = false;
+  ready = false;
+  connectionStatus;
+  connectionError;
+  connectionErrorCode;
+  connectionLastChangedAt = Date.now();
+  connectionListeners = /* @__PURE__ */ new Set();
+  handleSdkConnected = () => {
+    this.updateConnection("connected");
+  };
+  handleSdkDisconnected = () => {
+    const shouldReconnect = this.ready || this.connectionStatus === "connected" || this.connectionStatus === "reconnecting";
+    this.ready = false;
+    this.updateConnection(!this.disposed && shouldReconnect ? "reconnecting" : "disconnected");
+  };
+  handleSdkError = (error) => {
+    if (!this.sdk.isConnected()) {
+      this.ready = false;
+    }
+    this.updateConnection("error", normalizeConnectionError(error));
+  };
+  constructor(config) {
+    this.id = config.id ?? "sanqian";
+    this.displayName = config.displayName ?? "Sanqian";
+    this.sdk = config.sdk;
+    this.appName = config.appName;
+    this.agentConfigs = config.agents ?? [];
+    this.agentIdResolver = createSanqianAgentIdResolver(config.appName);
+    this.connectionStatus = this.sdk.isConnected() ? "connected" : "disconnected";
+    this.registerConnectionEvents();
+  }
+  // --- Lifecycle ---
+  async ensureReady() {
+    if (this.disposed) throw new Error("Provider disposed");
+    if (this.ready && this.sdk.isConnected()) return;
+    if (this.ready && !this.sdk.isConnected()) {
+      this.ready = false;
+    }
+    this.updateConnection(this.sdk.isConnected() ? "connected" : "connecting");
+    try {
+      await this.sdk.ensureReady();
+      this.updateConnection("connected");
+      await this.syncAgents();
+      this.ready = true;
+    } catch (error) {
+      this.ready = false;
+      this.updateConnection("error", normalizeConnectionError(error));
+      throw error;
+    }
+  }
+  async dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    this.ready = false;
+    this.agentIdResolver.clearMappings();
+    this.unregisterConnectionEvents();
+    this.updateConnection("disconnected");
+    this.sdk.removeAllListeners();
+    await this.sdk.disconnect();
+  }
+  isDisposed() {
+    return this.disposed;
+  }
+  // --- Agent Sync ---
+  async syncAgents() {
+    for (const config of this.agentConfigs) {
+      const sdkConfig = {
+        agent_id: config.id,
+        name: config.name,
+        description: config.description,
+        system_prompt: config.systemPrompt,
+        tools: config.tools
+      };
+      const result = await this.sdk.createAgent(sdkConfig);
+      this.agentIdResolver.setMapping(config.id, result.agent_id);
+    }
+  }
+  /**
+   * Get the registered Sanqian agent ID for a runtime agent ID.
+   */
+  async resolveAgentId(shortId) {
+    return this.agentIdResolver.toProviderAgentId(shortId);
+  }
+  /**
+   * Get the runtime agent ID for a registered Sanqian agent ID.
+   */
+  normalizeAgentId(registeredId) {
+    return this.agentIdResolver.toRuntimeAgentId(registeredId);
+  }
+  // --- Chat ---
+  async chat(input) {
+    this.ensureNotDisposed();
+    const agentId = await this.resolveAgentId(input.agentId);
+    const messages = input.messages.map((m) => ({ role: m.role, content: m.content }));
+    const response = await this.sdk.chat(agentId, messages, {
+      conversationId: input.conversationId ?? void 0
+    });
+    return {
+      content: response.message.content,
+      conversationId: response.conversationId || void 0,
+      usage: response.usage ? {
+        promptTokens: response.usage.prompt_tokens,
+        completionTokens: response.usage.completion_tokens,
+        totalTokens: response.usage.total_tokens
+      } : void 0
+    };
+  }
+  async *chatStream(input) {
+    this.ensureNotDisposed();
+    const agentId = await this.resolveAgentId(input.agentId);
+    const messages = input.messages.map((m) => ({ role: m.role, content: m.content }));
+    const stream = this.sdk.chatStream(agentId, messages, {
+      conversationId: input.conversationId ?? void 0,
+      signal: input.signal,
+      attachedResources: input.resources?.map((r) => `${r.providerId}:${r.resourceId}`),
+      sessionResources: input.sessionResources?.map((r) => r.id)
+    });
+    for await (const sdkEvent of stream) {
+      if (input.signal?.aborted) {
+        yield { type: "cancelled" };
+        return;
+      }
+      const runtimeEvent = convertSdkStreamEvent(sdkEvent);
+      if (runtimeEvent) {
+        yield runtimeEvent;
+      }
+    }
+  }
+  // --- Cancel / HITL ---
+  async cancel(runId) {
+    this.ensureNotDisposed();
+    this.sdk.cancelRun(runId);
+  }
+  async sendPermissionResponse(input) {
+    this.ensureNotDisposed();
+    this.sdk.sendHitlResponse(input.runId, input.response ?? {
+      approved: input.decision === "approve",
+      cancelled: input.decision === "cancel"
+    });
+  }
+  // --- Conversations ---
+  async listConversations(options) {
+    this.ensureNotDisposed();
+    return this.sdk.listConversations({
+      agentId: options?.agentId,
+      limit: options?.limit,
+      offset: options?.offset
+    });
+  }
+  async getConversation(id, options) {
+    this.ensureNotDisposed();
+    return this.sdk.getConversation(id, options);
+  }
+  async deleteConversation(id) {
+    this.ensureNotDisposed();
+    return this.sdk.deleteConversation(id);
+  }
+  // --- Session Resources ---
+  getSessionResources() {
+    return this.sdk.getSessionResources();
+  }
+  async pushResource(resource) {
+    this.ensureNotDisposed();
+    return this.sdk.pushResource(resource);
+  }
+  async removeResource(resourceId) {
+    this.ensureNotDisposed();
+    return this.sdk.removeResource(resourceId);
+  }
+  // --- Embedding / Rerank ---
+  async getEmbeddingConfig() {
+    try {
+      return await this.sdk.getEmbeddingConfig();
+    } catch {
+      return null;
+    }
+  }
+  async getRerankConfig() {
+    try {
+      return await this.sdk.getRerankConfig();
+    } catch {
+      return null;
+    }
+  }
+  // --- Connection lifecycle ---
+  acquireReconnect() {
+    this.sdk.acquireReconnect();
+  }
+  releaseReconnect() {
+    this.sdk.releaseReconnect();
+  }
+  // --- Connection state ---
+  isConnected() {
+    return this.sdk.isConnected();
+  }
+  getConnectionSnapshot() {
+    return {
+      status: this.connectionStatus,
+      isConnected: this.sdk.isConnected(),
+      error: this.connectionError,
+      errorCode: this.connectionErrorCode,
+      lastChangedAt: this.connectionLastChangedAt
+    };
+  }
+  onConnectionChange(callback) {
+    this.connectionListeners.add(callback);
+    callback(this.getConnectionSnapshot());
+    return () => {
+      this.connectionListeners.delete(callback);
+    };
+  }
+  // --- Events (Sanqian-specific, not on RuntimeProvider interface) ---
+  on(event, handler) {
+    this.sdk.on(event, handler);
+  }
+  off(event, handler) {
+    this.sdk.off(event, handler);
+  }
+  // --- Capability discovery ---
+  async listAvailableAgents() {
+    this.ensureNotDisposed();
+    const sdk = this.sdk;
+    if (typeof sdk.listAvailableAgents === "function") {
+      return sdk.listAvailableAgents();
+    }
+    return [];
+  }
+  // --- Internal ---
+  ensureNotDisposed() {
+    if (this.disposed) throw new Error("Provider disposed");
+  }
+  registerConnectionEvents() {
+    this.sdk.on("connected", this.handleSdkConnected);
+    this.sdk.on("disconnected", this.handleSdkDisconnected);
+    this.sdk.on("error", this.handleSdkError);
+  }
+  unregisterConnectionEvents() {
+    this.sdk.off("connected", this.handleSdkConnected);
+    this.sdk.off("disconnected", this.handleSdkDisconnected);
+    this.sdk.off("error", this.handleSdkError);
+  }
+  updateConnection(status, options = {}) {
+    const nextError = status === "error" ? options.error : void 0;
+    const nextErrorCode = status === "error" ? options.errorCode : void 0;
+    if (this.connectionStatus === status && this.connectionError === nextError && this.connectionErrorCode === nextErrorCode) {
+      return;
+    }
+    this.connectionStatus = status;
+    this.connectionError = nextError;
+    this.connectionErrorCode = nextErrorCode;
+    this.connectionLastChangedAt = Date.now();
+    const snapshot = this.getConnectionSnapshot();
+    for (const listener of this.connectionListeners) {
+      listener(snapshot);
+    }
+  }
+};
+function normalizeConnectionError(error) {
+  if (error instanceof Error) {
+    const code = error.code;
+    return {
+      error: error.message || "Connection failed",
+      errorCode: typeof code === "string" && code.trim() ? code : "CONNECTION_FAILED"
+    };
+  }
+  if (error && typeof error === "object") {
+    const record = error;
+    const message = typeof record.message === "string" ? record.message : "Connection failed";
+    const code = typeof record.code === "string" && record.code.trim() ? record.code : "CONNECTION_FAILED";
+    return { error: message, errorCode: code };
+  }
+  if (typeof error === "string" && error.trim()) {
+    return { error, errorCode: "CONNECTION_FAILED" };
+  }
+  return { error: "Connection failed", errorCode: "CONNECTION_FAILED" };
+}
+
+// src/providers/sanqian/mock-sdk.ts
+var MockSanqianSdk = class {
+  appName;
+  connected;
+  readinessError;
+  scenarios;
+  agents = /* @__PURE__ */ new Map();
+  conversations = /* @__PURE__ */ new Map();
+  sessionResources = [];
+  listeners = /* @__PURE__ */ new Map();
+  embeddingConfig;
+  rerankConfig;
+  // Tracking for assertions
+  connectCalls = [];
+  disconnectCalls = [];
+  ensureReadyCalls = [];
+  createAgentCalls = [];
+  chatCalls = [];
+  chatStreamCalls = [];
+  cancelRunCalls = [];
+  hitlResponseCalls = [];
+  constructor(config = {}) {
+    this.appName = config.appName ?? "test-app";
+    this.connected = config.connected ?? false;
+    this.readinessError = config.readinessError ?? null;
+    this.scenarios = config.scenarios ?? [];
+    this.embeddingConfig = config.embeddingConfig ?? { available: false };
+    this.rerankConfig = config.rerankConfig ?? { available: false };
+  }
+  // --- Connection ---
+  async connect() {
+    this.connectCalls.push(Date.now());
+    if (this.readinessError) throw new Error(this.readinessError);
+    this.connected = true;
+    this.emit("connected");
+  }
+  async disconnect() {
+    this.disconnectCalls.push(Date.now());
+    this.connected = false;
+    this.emit("disconnected");
+  }
+  async ensureReady() {
+    this.ensureReadyCalls.push(Date.now());
+    if (this.readinessError) throw new Error(this.readinessError);
+    if (!this.connected) {
+      await this.connect();
+    }
+  }
+  isConnected() {
+    return this.connected;
+  }
+  acquireReconnect() {
+  }
+  releaseReconnect() {
+  }
+  // --- Events ---
+  on(event, handler) {
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, /* @__PURE__ */ new Set());
+    }
+    this.listeners.get(event).add(handler);
+  }
+  off(event, handler) {
+    this.listeners.get(event)?.delete(handler);
+  }
+  removeAllListeners() {
+    this.listeners.clear();
+  }
+  emit(event, ...args) {
+    const handlers = this.listeners.get(event);
+    if (handlers) {
+      for (const handler of handlers) {
+        handler(...args);
+      }
+    }
+  }
+  // --- Agents ---
+  async createAgent(config) {
+    this.createAgentCalls.push(config);
+    const registeredId = `${this.appName}:${config.agent_id}`;
+    this.agents.set(config.agent_id, { agent_id: registeredId });
+    return { agent_id: registeredId };
+  }
+  // --- Chat ---
+  async chat(agentId, messages, options) {
+    this.chatCalls.push({ agentId, messages, options });
+    const scenario = this.findScenario(agentId);
+    if (scenario?.error) throw new Error(scenario.error);
+    const content = scenario?.chatResponse ?? "Mock response";
+    return {
+      message: { content, role: "assistant" },
+      conversationId: options?.conversationId ?? "conv-mock",
+      usage: { prompt_tokens: 10, completion_tokens: 5, total_tokens: 15 }
+    };
+  }
+  async *chatStream(agentId, messages, options) {
+    this.chatStreamCalls.push({ agentId, messages, options });
+    const scenario = this.findScenario(agentId);
+    if (scenario?.error) {
+      yield { type: "error", error: scenario.error };
+      return;
+    }
+    if (scenario?.streamEvents) {
+      for (const event of scenario.streamEvents) {
+        if (options?.signal?.aborted) {
+          yield { type: "cancelled", run_id: "run-mock" };
+          return;
+        }
+        yield event;
+      }
+      return;
+    }
+    if (options?.signal?.aborted) {
+      yield { type: "cancelled", run_id: "run-mock" };
+      return;
+    }
+    yield { type: "start", run_id: "run-mock" };
+    if (options?.signal?.aborted) {
+      yield { type: "cancelled", run_id: "run-mock" };
+      return;
+    }
+    yield { type: "text", content: scenario?.chatResponse ?? "Mock streamed response" };
+    yield { type: "done", conversationId: options?.conversationId ?? "conv-mock" };
+  }
+  // --- Cancel / HITL ---
+  cancelRun(runId) {
+    this.cancelRunCalls.push(runId);
+  }
+  sendHitlResponse(runId, response) {
+    this.hitlResponseCalls.push({ runId, response });
+  }
+  // --- Conversations ---
+  async listConversations(options) {
+    const all = Array.from(this.conversations.values());
+    const filtered = options.agentId ? all.filter((c) => c.agent_id === options.agentId) : all;
+    const offset = options.offset ?? 0;
+    const limit = options.limit ?? 20;
+    return {
+      conversations: filtered.slice(offset, offset + limit),
+      total: filtered.length
+    };
+  }
+  async getConversation(id) {
+    const conv = this.conversations.get(id);
+    if (!conv) throw new Error(`Conversation not found: ${id}`);
+    return conv;
+  }
+  async deleteConversation(id) {
+    this.conversations.delete(id);
+  }
+  /** Test helper: seed a conversation */
+  seedConversation(detail) {
+    this.conversations.set(detail.conversation_id, detail);
+  }
+  // --- Session Resources ---
+  getSessionResources() {
+    return [...this.sessionResources];
+  }
+  async pushResource(resource) {
+    const stored = {
+      ...resource,
+      fullId: `${this.appName}:${resource.id ?? `res-${Date.now()}`}`,
+      appName: this.appName,
+      pushedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.sessionResources.push(stored);
+    this.emit("resourcePushed", stored);
+    return stored;
+  }
+  async removeResource(resourceId) {
+    this.sessionResources = this.sessionResources.filter((r) => r.fullId !== resourceId);
+    this.emit("resourceRemoved", resourceId);
+  }
+  async fetchSessionResources() {
+    return [...this.sessionResources];
+  }
+  // --- Embedding / Rerank ---
+  async getEmbeddingConfig() {
+    return this.embeddingConfig;
+  }
+  async getRerankConfig() {
+    return this.rerankConfig;
+  }
+  // --- Helpers ---
+  findScenario(agentId) {
+    return this.scenarios.find((s) => !s.agentId || s.agentId === agentId);
+  }
+  /** Simulate readiness failure for testing rollback */
+  setReadinessError(error) {
+    this.readinessError = error;
+  }
+  /** Force connection state for testing */
+  setConnected(connected) {
+    this.connected = connected;
+  }
+};
+
+// src/providers/sanqian/embedding-provider.ts
+var DEFAULT_BATCH_SIZE = 50;
+var DEFAULT_TIMEOUT = 3e4;
+var SanqianEmbeddingProvider = class {
+  id;
+  model;
+  dimensions;
+  config;
+  disposed = false;
+  constructor(config, id) {
+    this.config = config;
+    this.id = id ?? "sanqian-embedding";
+    this.model = config.modelName;
+    this.dimensions = config.dimensions;
+  }
+  async ensureReady() {
+    if (this.disposed) throw new Error("Provider disposed");
+    if (!this.config.apiUrl) throw new Error("Embedding API URL not configured");
+    if (this.config.apiType !== "local" && !this.config.apiKey) {
+      throw new Error("Embedding API Key not configured");
+    }
+  }
+  async dispose() {
+    this.disposed = true;
+  }
+  async embedMany(texts, options) {
+    if (this.disposed) throw new Error("Provider disposed");
+    if (texts.length === 0) return [];
+    if (texts.length <= DEFAULT_BATCH_SIZE) {
+      return this.callApi(texts, options?.signal);
+    }
+    const allEmbeddings = [];
+    for (let i = 0; i < texts.length; i += DEFAULT_BATCH_SIZE) {
+      if (options?.signal?.aborted) throw new Error("Embedding request aborted");
+      const batch = texts.slice(i, i + DEFAULT_BATCH_SIZE);
+      const batchEmbeddings = await this.callApi(batch, options?.signal);
+      allEmbeddings.push(...batchEmbeddings);
+    }
+    return allEmbeddings;
+  }
+  async embed(text, options) {
+    const [result] = await this.embedMany([text], options);
+    if (!result) throw new Error("Failed to generate embedding");
+    return result;
+  }
+  async test() {
+    try {
+      const embedding = await this.embed("Hello, this is a test.");
+      return { success: true, dimensions: embedding.length };
+    } catch (error) {
+      return { success: false, error: error instanceof Error ? error.message : "Unknown error" };
+    }
+  }
+  async callApi(texts, signal) {
+    const { apiUrl, apiKey, modelName, apiType } = this.config;
+    if (apiType === "local") {
+      return this.callOllama(texts, signal);
+    }
+    const headers = {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${apiKey}`
+    };
+    const response = await fetch(apiUrl, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ input: texts, model: modelName }),
+      signal: signal ?? AbortSignal.timeout(DEFAULT_TIMEOUT)
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`Embedding API error: ${response.status} - ${errorText.slice(0, 100)}`);
+    }
+    const data = await response.json();
+    const sorted = data.data.sort((a, b) => a.index - b.index);
+    const embeddings = sorted.map((item) => item.embedding);
+    if (embeddings.length !== texts.length) {
+      throw new Error(`Embedding count mismatch: expected ${texts.length}, got ${embeddings.length}`);
+    }
+    return embeddings;
+  }
+  async callOllama(texts, signal) {
+    const { apiUrl, apiKey, modelName } = this.config;
+    const headers = { "Content-Type": "application/json" };
+    if (apiKey) headers["Authorization"] = `Bearer ${apiKey}`;
+    const embeddings = [];
+    for (const text of texts) {
+      if (signal?.aborted) throw new Error("Embedding request aborted");
+      const response = await fetch(apiUrl, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({ model: modelName, prompt: text }),
+        signal: signal ?? AbortSignal.timeout(DEFAULT_TIMEOUT)
+      });
+      if (!response.ok) throw new Error(`Ollama API error: ${response.status}`);
+      const data = await response.json();
+      embeddings.push(data.embedding);
+    }
+    return embeddings;
+  }
+};
+
+// src/providers/sanqian/rerank-provider.ts
+var SanqianRerankProvider = class {
+  id;
+  model;
+  config;
+  disposed = false;
+  constructor(config, id) {
+    this.id = id ?? "sanqian-rerank";
+    this.model = config.modelName;
+    this.config = config;
+  }
+  async ensureReady() {
+    if (this.disposed) throw new Error("Provider disposed");
+    if (!this.config.apiUrl) throw new Error("Rerank API URL not configured");
+    if (!this.config.apiKey) throw new Error("Rerank API Key not configured");
+  }
+  async dispose() {
+    this.disposed = true;
+  }
+  async rerank(input, options) {
+    if (this.disposed) throw new Error("Provider disposed");
+    if (input.documents.length === 0) return { results: [] };
+    const { apiUrl, apiKey, modelName } = this.config;
+    const response = await fetch(apiUrl, {
+      method: "POST",
+      headers: {
+        "Authorization": `Bearer ${apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        model: modelName,
+        query: input.query,
+        documents: input.documents.map((d) => d.text),
+        top_n: input.topN ?? input.documents.length,
+        return_documents: false
+      }),
+      signal: options?.signal
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`Rerank API error: ${response.status} - ${errorText.slice(0, 100)}`);
+    }
+    const data = await response.json();
+    if (!data.results?.length) return { results: [] };
+    const results = data.results.filter((r) => r.index >= 0 && r.index < input.documents.length).sort((a, b) => b.relevance_score - a.relevance_score).map((r) => ({
+      id: input.documents[r.index].id,
+      score: r.relevance_score,
+      index: r.index
+    }));
+    return { results };
+  }
+  async test() {
+    try {
+      const result = await this.rerank({
+        query: "test",
+        documents: [{ id: "1", text: "doc one" }, { id: "2", text: "doc two" }],
+        topN: 2
+      });
+      return { success: result.results.length > 0 };
+    } catch (error) {
+      return { success: false, error: error instanceof Error ? error.message : "Unknown error" };
+    }
+  }
+};
+
+// src/providers/vercel/provider.ts
+var import_ai = require("ai");
+var import_openai_compatible = require("@ai-sdk/openai-compatible");
+
+// src/providers/vercel/tool-converter.ts
+var import_zod = require("zod");
+function jsonSchemaToZod(schema) {
+  switch (schema.type) {
+    case "string":
+      return import_zod.z.string();
+    case "number":
+      return import_zod.z.number();
+    case "integer":
+      return import_zod.z.number().int();
+    case "boolean":
+      return import_zod.z.boolean();
+    case "array": {
+      const items = schema.items;
+      return import_zod.z.array(items ? jsonSchemaToZod(items) : import_zod.z.unknown());
+    }
+    case "object":
+      break;
+  }
+  const properties = schema.properties;
+  const required = schema.required ?? [];
+  if (!properties || Object.keys(properties).length === 0) {
+    return import_zod.z.object({});
+  }
+  const shape = {};
+  for (const [key, prop] of Object.entries(properties)) {
+    let field;
+    switch (prop.type) {
+      case "string":
+        field = import_zod.z.string();
+        break;
+      case "number":
+      case "integer":
+        field = import_zod.z.number();
+        break;
+      case "boolean":
+        field = import_zod.z.boolean();
+        break;
+      case "array": {
+        const items = prop.items;
+        field = import_zod.z.array(items ? jsonSchemaToZod(items) : import_zod.z.unknown());
+        break;
+      }
+      case "object":
+        field = jsonSchemaToZod(prop);
+        break;
+      default:
+        field = import_zod.z.unknown();
+    }
+    if (prop.description) {
+      field = field.describe(prop.description);
+    }
+    if (!required.includes(key)) {
+      field = field.optional();
+    }
+    shape[key] = field;
+  }
+  return import_zod.z.object(shape);
+}
+function convertToolsForVercel(tools, registry, options) {
+  const result = {};
+  for (const tool of tools) {
+    const zodSchema = jsonSchemaToZod(tool.parameters);
+    if (registry) {
+      const reg = registry;
+      result[tool.name] = {
+        type: "function",
+        description: tool.description,
+        inputSchema: zodSchema,
+        execute: async (args) => {
+          const execResult = await reg.execute({
+            toolCallId: `tc-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
+            name: tool.name,
+            args,
+            signal: options?.signal
+          });
+          if (!execResult.success) {
+            throw new Error(execResult.error ?? "Tool execution failed");
+          }
+          return execResult.result;
+        }
+      };
+    } else {
+      result[tool.name] = {
+        type: "function",
+        description: tool.description,
+        inputSchema: zodSchema
+      };
+    }
+  }
+  return result;
+}
+
+// src/providers/vercel/provider.ts
+var VERCEL_CAPABILITIES = {
+  streamingText: true,
+  reasoning: true,
+  toolCalling: true,
+  parallelToolCalls: false,
+  // serialize mutations for safety
+  toolArgsStreaming: false,
+  abort: true,
+  hitl: false,
+  // local permission policy, not backend HITL
+  conversations: false,
+  // needs local ConversationStore
+  sessionResources: false,
+  resourcePicker: false,
+  embeddings: false,
+  rerank: false
+};
+var DEFAULT_MAX_STEPS = 5;
+var TOOL_STEP_LIMIT_ERROR = "Tool step limit reached before the model produced a final response.";
+var TOOL_STEP_LIMIT_ERROR_CODE = "TOOL_STEP_LIMIT";
+var VercelProvider = class {
+  id;
+  kind = "vercel-ai-sdk";
+  displayName;
+  capabilities = VERCEL_CAPABILITIES;
+  apiKey;
+  baseURL;
+  modelName;
+  providerName;
+  agentConfigs;
+  toolRegistry;
+  maxSteps;
+  disposed = false;
+  ready = false;
+  constructor(config) {
+    this.id = config.id ?? "vercel";
+    this.displayName = config.displayName ?? config.providerName ?? "Vercel AI";
+    this.apiKey = config.apiKey;
+    this.baseURL = config.baseURL;
+    this.modelName = config.model;
+    this.providerName = config.providerName ?? "openai-compatible";
+    this.toolRegistry = config.toolRegistry ?? null;
+    this.maxSteps = config.maxSteps ?? DEFAULT_MAX_STEPS;
+    this.agentConfigs = /* @__PURE__ */ new Map();
+    for (const agent of config.agents ?? []) {
+      this.agentConfigs.set(agent.id, agent);
+    }
+  }
+  // --- Lifecycle ---
+  async ensureReady() {
+    if (this.disposed) throw new Error("Provider disposed");
+    if (this.ready) return;
+    if (!this.apiKey) throw new Error("API key is required");
+    if (!this.baseURL) throw new Error("Base URL is required");
+    if (!this.modelName) throw new Error("Model name is required");
+    const provider = this.createProvider();
+    try {
+      await (0, import_ai.generateText)({
+        model: provider.chatModel(this.modelName),
+        prompt: "Reply with OK",
+        maxOutputTokens: 32,
+        abortSignal: AbortSignal.timeout(15e3)
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Provider readiness check failed";
+      const redacted = message.replace(new RegExp(this.apiKey.slice(0, 8), "g"), "****");
+      throw new Error(`Provider readiness failed: ${redacted}`);
+    }
+    this.ready = true;
+  }
+  async dispose() {
+    this.disposed = true;
+    this.ready = false;
+  }
+  isDisposed() {
+    return this.disposed;
+  }
+  // --- Chat ---
+  async chat(input) {
+    this.ensureNotDisposed();
+    const agentConfig = this.agentConfigs.get(input.agentId);
+    const provider = this.createProvider();
+    const model = provider.chatModel(this.modelName);
+    const { system, userMessages } = this.buildMessages(input.messages, agentConfig);
+    const tools = this.resolveTools(input, agentConfig);
+    const maxSteps = tools ? this.maxSteps : 1;
+    const result = await (0, import_ai.generateText)({
+      model,
+      system,
+      messages: userMessages,
+      tools,
+      stopWhen: (0, import_ai.stepCountIs)(maxSteps),
+      abortSignal: input.signal
+    });
+    const resultWithSteps = result;
+    if (tools && resultWithSteps.finishReason === "tool-calls" && (resultWithSteps.steps?.length ?? 0) >= maxSteps) {
+      throw new Error(TOOL_STEP_LIMIT_ERROR);
+    }
+    const usage = result.usage;
+    return {
+      content: result.text,
+      usage: usage ? {
+        promptTokens: usage.inputTokens ?? 0,
+        completionTokens: usage.outputTokens ?? 0,
+        totalTokens: (usage.inputTokens ?? 0) + (usage.outputTokens ?? 0)
+      } : void 0
+    };
+  }
+  async *chatStream(input) {
+    this.ensureNotDisposed();
+    const agentConfig = this.agentConfigs.get(input.agentId);
+    const provider = this.createProvider();
+    const model = provider.chatModel(this.modelName);
+    const { system, userMessages } = this.buildMessages(input.messages, agentConfig);
+    const tools = this.resolveTools(input, agentConfig);
+    const maxSteps = tools ? this.maxSteps : 1;
+    const runId = `run-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    yield { type: "start", runId };
+    try {
+      let completedSteps = 0;
+      let finishReason;
+      const result = (0, import_ai.streamText)({
+        model,
+        system,
+        messages: userMessages,
+        tools,
+        stopWhen: (0, import_ai.stepCountIs)(maxSteps),
+        abortSignal: input.signal
+      });
+      for await (const part of result.fullStream) {
+        if (input.signal?.aborted) {
+          yield { type: "cancelled", runId };
+          return;
+        }
+        const partType = part.type;
+        switch (partType) {
+          case "text-delta": {
+            const textPart = part;
+            if (textPart.text) {
+              yield { type: "text", content: textPart.text };
+            }
+            break;
+          }
+          case "reasoning-delta": {
+            const reasoningPart = part;
+            if (reasoningPart.text) {
+              yield { type: "thinking", content: reasoningPart.text };
+            }
+            break;
+          }
+          case "tool-call": {
+            const toolPart = part;
+            yield {
+              type: "tool_call",
+              toolCall: {
+                id: toolPart.toolCallId,
+                name: toolPart.toolName,
+                arguments: JSON.stringify(toolPart.input)
+              }
+            };
+            break;
+          }
+          case "tool-result": {
+            const resultPart = part;
+            yield {
+              type: "tool_result",
+              toolCallId: resultPart.toolCallId,
+              result: resultPart.output,
+              success: true
+            };
+            break;
+          }
+          case "finish-step": {
+            const finishPart = part;
+            completedSteps += 1;
+            finishReason = finishPart.finishReason;
+            break;
+          }
+          case "finish": {
+            const finishPart = part;
+            finishReason = finishPart.finishReason;
+            break;
+          }
+          case "tool-error": {
+            const errorPart = part;
+            const errMsg = errorPart.error instanceof Error ? errorPart.error.message : String(errorPart.error);
+            yield {
+              type: "tool_result",
+              toolCallId: errorPart.id ?? errorPart.toolCallId ?? "",
+              success: false,
+              error: this.redactSecrets(errMsg)
+            };
+            break;
+          }
+          case "error": {
+            const errPart = part;
+            const errorMessage = errPart.error instanceof Error ? errPart.error.message : String(errPart.error ?? "Unknown error");
+            yield { type: "error", error: this.redactSecrets(errorMessage) };
+            return;
+          }
+          // text-start, text-end, reasoning-start, reasoning-end,
+          // tool-input-start, tool-input-end, tool-input-delta,
+          // start-step, source, file - skip
+          default:
+            break;
+        }
+      }
+      if (tools && finishReason === "tool-calls" && completedSteps >= maxSteps) {
+        yield {
+          type: "error",
+          error: TOOL_STEP_LIMIT_ERROR,
+          code: TOOL_STEP_LIMIT_ERROR_CODE
+        };
+        return;
+      }
+      yield { type: "done", conversationId: input.conversationId ?? "" };
+    } catch (error) {
+      if (input.signal?.aborted) {
+        yield { type: "cancelled", runId };
+        return;
+      }
+      const message = error instanceof Error ? error.message : "Stream error";
+      yield { type: "error", error: this.redactSecrets(message) };
+    }
+  }
+  // --- Cancel ---
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  async cancel(_runId) {
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  async sendPermissionResponse(_input) {
+  }
+  // --- Internal ---
+  createProvider() {
+    return (0, import_openai_compatible.createOpenAICompatible)({
+      name: this.providerName,
+      apiKey: this.apiKey,
+      baseURL: this.baseURL
+    });
+  }
+  buildMessages(messages, agentConfig) {
+    const systemParts = [];
+    if (agentConfig?.systemPrompt) {
+      systemParts.push(agentConfig.systemPrompt);
+    }
+    const userMessages = [];
+    for (const msg of messages) {
+      if (msg.role === "system") {
+        if (!agentConfig?.systemPrompt || msg.content !== agentConfig.systemPrompt) {
+          systemParts.push(msg.content);
+        }
+      } else {
+        userMessages.push({
+          role: msg.role,
+          content: msg.content
+        });
+      }
+    }
+    return {
+      system: systemParts.length > 0 ? systemParts.join("\n\n") : void 0,
+      userMessages
+    };
+  }
+  resolveTools(input, agentConfig) {
+    const toolDefs = input.tools;
+    if (toolDefs && toolDefs.length > 0) {
+      return convertToolsForVercel(toolDefs, this.toolRegistry, { signal: input.signal });
+    }
+    if (agentConfig?.tools && agentConfig.tools.length > 0 && this.toolRegistry) {
+      const registeredTools = agentConfig.tools.map((name) => this.toolRegistry.get(name)).filter((t) => t !== void 0).map((t) => t.definition);
+      if (registeredTools.length > 0) {
+        return convertToolsForVercel(registeredTools, this.toolRegistry, { signal: input.signal });
+      }
+    }
+    return void 0;
+  }
+  redactSecrets(message) {
+    if (this.apiKey && this.apiKey.length > 8) {
+      const prefix = this.apiKey.slice(0, 8);
+      return message.replace(new RegExp(prefix, "g"), "****");
+    }
+    return message;
+  }
+  ensureNotDisposed() {
+    if (this.disposed) throw new Error("Provider disposed");
+  }
+};
+
+// src/providers/vercel/embedding-provider.ts
+var import_ai2 = require("ai");
+var import_openai_compatible2 = require("@ai-sdk/openai-compatible");
+var VercelEmbeddingProvider = class {
+  id;
+  model;
+  dimensions;
+  config;
+  disposed = false;
+  constructor(config, id) {
+    this.id = id ?? "vercel-embedding";
+    this.model = config.model;
+    this.dimensions = config.dimensions;
+    this.config = config;
+  }
+  async ensureReady() {
+    if (this.disposed) throw new Error("Provider disposed");
+    if (!this.config.apiKey) throw new Error("Embedding API key is required");
+    if (!this.config.baseURL) throw new Error("Embedding base URL is required");
+    try {
+      const provider = this.createProvider();
+      const result = await (0, import_ai2.embed)({
+        model: provider.textEmbeddingModel(this.config.model),
+        value: "test",
+        abortSignal: AbortSignal.timeout(15e3)
+      });
+      if (!result.embedding?.length) throw new Error("Empty embedding result");
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : "Embedding readiness failed";
+      throw new Error(`Embedding provider not ready: ${this.redact(msg)}`);
+    }
+  }
+  async dispose() {
+    this.disposed = true;
+  }
+  async embedMany(texts, options) {
+    if (this.disposed) throw new Error("Provider disposed");
+    if (texts.length === 0) return [];
+    const provider = this.createProvider();
+    const result = await (0, import_ai2.embedMany)({
+      model: provider.textEmbeddingModel(this.config.model),
+      values: texts,
+      abortSignal: options?.signal
+    });
+    return result.embeddings;
+  }
+  async embed(text, options) {
+    if (this.disposed) throw new Error("Provider disposed");
+    const provider = this.createProvider();
+    const result = await (0, import_ai2.embed)({
+      model: provider.textEmbeddingModel(this.config.model),
+      value: text,
+      abortSignal: options?.signal
+    });
+    return result.embedding;
+  }
+  async test() {
+    try {
+      const embedding = await this.embed("Hello, this is a test.");
+      return { success: true, dimensions: embedding.length };
+    } catch (error) {
+      return { success: false, error: error instanceof Error ? error.message : "Unknown error" };
+    }
+  }
+  createProvider() {
+    return (0, import_openai_compatible2.createOpenAICompatible)({
+      name: this.config.providerName ?? "embedding-provider",
+      apiKey: this.config.apiKey,
+      baseURL: this.config.baseURL
+    });
+  }
+  redact(message) {
+    if (this.config.apiKey?.length > 8) {
+      return message.replace(new RegExp(this.config.apiKey.slice(0, 8), "g"), "****");
+    }
+    return message;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EMPTY_CAPABILITIES,
+  MockSanqianSdk,
+  SanqianEmbeddingProvider,
+  SanqianProvider,
+  SanqianRerankProvider,
+  VercelEmbeddingProvider,
+  VercelProvider,
+  convertSdkStreamEvent,
+  convertToolsForVercel,
+  createActiveWorkTracker,
+  createCategoryPermissionPolicy,
+  createChatRuntimeBridge,
+  createDefaultPermissionPolicy,
+  createDisabledState,
+  createEmbeddingSession,
+  createMemoryConversationStore,
+  createMemorySecretStore,
+  createOutputOperationsManager,
+  createPermissionGate,
+  createSanqianAgentIdResolver,
+  createSessionManager,
+  createTaskPipeline,
+  createToolRegistry,
+  redactToolError,
+  resolveAiFeaturesFromRuntime,
+  validateOutputContent
+});
+//# sourceMappingURL=index.js.map