@shwfed/config 1.0.0 → 1.0.1

package/dist/runtime/plugins/ai/index.js

@@ -1,13 +1,10 @@
 import { defineNuxtPlugin } from "#app";
 import { computed } from "vue";
 import { JSONSchema, Schema } from "effect";
-import { isByokAllowed } from "./gate.js";
-import { createConfigRef, DEFAULT_MAX_TOKENS as CONFIG_DEFAULT_MAX_TOKENS } from "./store.js";
-import { settingsOpen } from "./settings-state.js";
-const DEFAULT_ANTHROPIC_MODEL = "claude-sonnet-4-5-20250929";
-const DEFAULT_ANTHROPIC_ENDPOINT = "https://api.anthropic.com/v1/messages";
-const DEFAULT_OPENAI_MODEL = "gpt-4o-mini";
-const DEFAULT_OPENAI_ENDPOINT = "https://api.openai.com/v1/chat/completions";
+const ENDPOINT = "http://192.168.168.10/anthropic/v1/messages";
+const MODEL = "MiniMax-M2.7";
+const ANTHROPIC_VERSION = "2023-06-01";
+const DEFAULT_MAX_TOKENS = 8192;
 export class StructuredOutputDecodeError extends Error {
   rawOutput;
   constructor(rawOutput, cause) {
@@ -51,467 +48,214 @@ async function* readSSE(res) {
     }
   }
 }
-function buildAnthropicClient(cfg) {
-  const endpoint = cfg.endpoint ?? DEFAULT_ANTHROPIC_ENDPOINT;
-  const model = cfg.model ?? DEFAULT_ANTHROPIC_MODEL;
-  const configuredMaxTokens = cfg.maxTokens ?? CONFIG_DEFAULT_MAX_TOKENS;
-  const RETRY_TOOL_USE_ID = "retry_call_0";
-  function buildBody(messages, options) {
-    return {
-      model,
-      max_tokens: options.maxTokens ?? configuredMaxTokens,
-      messages,
-      ...options.system !== void 0 ? { system: options.system } : {},
-      ...options.tools !== void 0 ? { tools: options.tools } : {},
-      ...options.toolChoice !== void 0 ? { tool_choice: options.toolChoice } : {}
-    };
-  }
-  function buildInitialMessages(prompt, retry) {
-    const messages = [{ role: "user", content: prompt }];
-    if (retry) {
-      messages.push({
-        role: "assistant",
-        content: [{
-          type: "tool_use",
-          id: RETRY_TOOL_USE_ID,
-          name: retry.toolName,
-          input: retry.previousOutput
-        }]
-      });
-      messages.push({
-        role: "user",
-        content: [{
-          type: "tool_result",
-          tool_use_id: RETRY_TOOL_USE_ID,
-          content: retry.feedback
-        }]
-      });
-    }
-    return messages;
-  }
-  function buildInit(body, signal) {
-    return {
-      method: "POST",
-      headers: {
-        "content-type": "application/json",
-        "x-api-key": cfg.apiKey,
-        "anthropic-version": "2023-06-01",
-        // CORS opt-in for browser-direct calls. The name is deliberately
-        // scary — keys live in localStorage on dev/beta only, gated by gate.ts.
-        "anthropic-dangerous-direct-browser-access": "true"
-      },
-      body: JSON.stringify(body),
-      ...signal ? { signal } : {}
-    };
+function buildBody(messages, system, options) {
+  return {
+    model: MODEL,
+    messages,
+    max_tokens: options.maxTokens ?? DEFAULT_MAX_TOKENS,
+    ...system !== void 0 ? { system } : {},
+    ...options.tools !== void 0 ? { tools: options.tools } : {},
+    ...options.toolChoice !== void 0 ? { tool_choice: options.toolChoice } : {}
+  };
+}
+function buildInit(body, signal) {
+  return {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      "anthropic-version": ANTHROPIC_VERSION,
+      "anthropic-dangerous-direct-browser-access": "true"
+    },
+    body: JSON.stringify(body),
+    ...signal ? { signal } : {}
+  };
+}
+async function call(messages, system, options, signal) {
+  const res = await fetch(ENDPOINT, buildInit(buildBody(messages, system, options), signal));
+  if (!res.ok) {
+    throw new Error(`Anthropic ${res.status}: ${await readError(res) || res.statusText}`);
   }
-  async function call(messages, options, signal) {
-    const res = await fetch(endpoint, buildInit(buildBody(messages, options), signal));
-    if (!res.ok) {
-      throw new Error(`Anthropic ${res.status}: ${await readError(res) || res.statusText}`);
-    }
-    return await res.json();
+  return await res.json();
+}
+async function callStream(messages, system, options, signal, onProgress) {
+  const body = { ...buildBody(messages, system, options), stream: true };
+  const res = await fetch(ENDPOINT, buildInit(body, signal));
+  if (!res.ok) {
+    throw new Error(`Anthropic ${res.status}: ${await readError(res) || res.statusText}`);
   }
-  async function callStream(messages, options, signal, onProgress) {
-    const body = { ...buildBody(messages, options), stream: true };
-    const res = await fetch(endpoint, buildInit(body, signal));
-    if (!res.ok) {
-      throw new Error(`Anthropic ${res.status}: ${await readError(res) || res.statusText}`);
+  const blocks = /* @__PURE__ */ new Map();
+  let stopReason;
+  for await (const ev of readSSE(res)) {
+    if (!ev.event || !ev.data) continue;
+    let payload;
+    try {
+      payload = JSON.parse(ev.data);
+    } catch {
+      continue;
     }
-    const blocks = /* @__PURE__ */ new Map();
-    for await (const ev of readSSE(res)) {
-      if (ev.event === "content_block_start") {
-        const data = JSON.parse(ev.data);
-        blocks.set(data.index, {
-          type: data.content_block.type,
-          id: data.content_block.id,
-          name: data.content_block.name,
-          text: "",
-          inputJson: ""
-        });
-      } else if (ev.event === "content_block_delta") {
-        const data = JSON.parse(ev.data);
-        const block = blocks.get(data.index);
-        if (!block) continue;
-        if (data.delta.type === "text_delta" && data.delta.text) {
-          block.text += data.delta.text;
-          onProgress();
-        } else if (data.delta.type === "input_json_delta" && data.delta.partial_json) {
-          block.inputJson += data.delta.partial_json;
-          onProgress();
-        }
+    const p = payload;
+    if (p.type === "content_block_start" && typeof p.index === "number" && p.content_block) {
+      const cb = p.content_block;
+      blocks.set(p.index, {
+        type: cb.type === "tool_use" ? "tool_use" : "text",
+        text: "",
+        toolId: cb.id,
+        toolName: cb.name,
+        inputJson: ""
+      });
+    } else if (p.type === "content_block_delta" && typeof p.index === "number" && p.delta) {
+      const cur = blocks.get(p.index);
+      if (!cur) continue;
+      if (p.delta.type === "text_delta" && p.delta.text) {
+        cur.text += p.delta.text;
+        onProgress();
+      } else if (p.delta.type === "input_json_delta" && p.delta.partial_json) {
+        cur.inputJson += p.delta.partial_json;
+        onProgress();
       }
+    } else if (p.type === "message_delta" && p.delta?.stop_reason) {
+      stopReason = p.delta.stop_reason;
+    } else if (p.type === "message_stop") {
+      break;
     }
-    const ordered = [...blocks.entries()].sort(([a], [b]) => a - b);
-    const content = ordered.map(([, block]) => {
-      if (block.type === "text") return { type: "text", text: block.text };
-      if (block.type === "tool_use") {
-        let input = {};
-        if (block.inputJson) {
-          try {
-            input = JSON.parse(block.inputJson);
-          } catch {
-          }
-        }
-        return {
-          type: "tool_use",
-          id: block.id ?? "",
-          name: block.name ?? "",
-          input
-        };
-      }
-      return { type: block.type };
-    });
-    return { content };
   }
-  function extractText(response) {
-    return response.content.filter((b) => b.type === "text").map((b) => b.text).join("");
-  }
-  return {
-    async generateText(input) {
-      const opts = {
-        ...input.system !== void 0 ? { system: input.system } : {},
-        ...input.maxTokens !== void 0 ? { maxTokens: input.maxTokens } : {}
-      };
-      const messages = [{ role: "user", content: input.prompt }];
-      const response = input.onProgress ? await callStream(messages, opts, input.signal, input.onProgress) : await call(messages, opts, input.signal);
-      return extractText(response);
-    },
-    async generateObject(input) {
-      const toolName = input.objectName ?? "structured_output";
-      const structuredSchema = JSONSchema.make(input.schema);
-      const helperTools = input.tools ?? [];
-      const helperByName = new Map(helperTools.map((t) => [t.name, t]));
-      const tools = [
-        ...helperTools.map((t) => ({
-          name: t.name,
-          description: t.description,
-          input_schema: t.inputJsonSchema
-        })),
-        {
-          name: toolName,
-          description: "Return the structured output as the tool input.",
-          input_schema: structuredSchema
-        }
-      ];
-      const toolChoice = helperTools.length > 0 ? { type: "any" } : { type: "tool", name: toolName };
-      const optsBase = {
-        ...input.system !== void 0 ? { system: input.system } : {},
-        ...input.maxTokens !== void 0 ? { maxTokens: input.maxTokens } : {},
-        tools,
-        toolChoice
-      };
-      const messages = buildInitialMessages(
-        input.prompt,
-        input.retry !== void 0 ? { ...input.retry, toolName } : void 0
-      );
-      const decode = (raw) => {
+  const content = [...blocks.entries()].sort(([a], [b]) => a - b).map(([, v]) => {
+    if (v.type === "tool_use") {
+      let input = {};
+      if (v.inputJson) {
         try {
-          return Schema.decodeUnknownSync(input.schema)(raw);
-        } catch (cause) {
-          throw new StructuredOutputDecodeError(raw, cause);
-        }
-      };
-      for (; ; ) {
-        const response = input.onProgress ? await callStream(messages, optsBase, input.signal, input.onProgress) : await call(messages, optsBase, input.signal);
-        const structured = response.content.find(
-          (b) => b.type === "tool_use" && b.name === toolName
-        );
-        if (structured) return decode(structured.input);
-        const helperCalls = response.content.filter(
-          (b) => b.type === "tool_use"
-        );
-        if (helperCalls.length === 0) {
-          const text = response.content.filter((b) => b.type === "text").map((b) => b.text).join("");
-          throw new Error(`\u6A21\u578B\u672A\u8FD4\u56DE\u7ED3\u6784\u5316\u8F93\u51FA${text ? `: ${text.slice(0, 200)}` : ""}`);
-        }
-        const toolResults = [];
-        for (const callBlock of helperCalls) {
-          const tool = helperByName.get(callBlock.name);
-          if (!tool) {
-            toolResults.push({
-              type: "tool_result",
-              tool_use_id: callBlock.id,
-              content: `Unknown tool: ${callBlock.name}`,
-              is_error: true
-            });
-            continue;
-          }
-          try {
-            const result = await tool.execute(callBlock.input);
-            toolResults.push({
-              type: "tool_result",
-              tool_use_id: callBlock.id,
-              content: typeof result === "string" ? result : JSON.stringify(result)
-            });
-          } catch (err) {
-            toolResults.push({
-              type: "tool_result",
-              tool_use_id: callBlock.id,
-              content: err instanceof Error ? err.message : String(err),
-              is_error: true
-            });
-          }
+          input = JSON.parse(v.inputJson);
+        } catch {
+          input = {};
         }
-        messages.push({ role: "assistant", content: response.content });
-        messages.push({ role: "user", content: toolResults });
       }
+      return {
+        type: "tool_use",
+        id: v.toolId ?? "",
+        name: v.toolName ?? "",
+        input
+      };
     }
-  };
+    return { type: "text", text: v.text };
+  });
+  return { content, stop_reason: stopReason };
 }
-function buildOpenAIClient(cfg) {
-  const endpoint = cfg.endpoint ?? DEFAULT_OPENAI_ENDPOINT;
-  const model = cfg.model ?? DEFAULT_OPENAI_MODEL;
-  const configuredMaxTokens = cfg.maxTokens ?? CONFIG_DEFAULT_MAX_TOKENS;
-  function buildBody(messages, options) {
-    return {
-      model,
-      messages,
-      max_tokens: options.maxTokens ?? configuredMaxTokens,
-      ...options.tools !== void 0 ? { tools: options.tools } : {},
-      ...options.toolChoice !== void 0 ? { tool_choice: options.toolChoice } : {}
-    };
-  }
-  function buildInit(body, signal) {
-    return {
-      method: "POST",
-      headers: {
-        "content-type": "application/json",
-        "authorization": `Bearer ${cfg.apiKey}`
-      },
-      body: JSON.stringify(body),
-      ...signal ? { signal } : {}
-    };
-  }
-  async function call(messages, options, signal) {
-    const res = await fetch(endpoint, buildInit(buildBody(messages, options), signal));
-    if (!res.ok) {
-      throw new Error(`OpenAI ${res.status}: ${await readError(res) || res.statusText}`);
+const RETRY_TOOL_USE_ID = "retry_call_0";
+function buildUserMessages(prompt) {
+  return [{ role: "user", content: prompt }];
+}
+function appendRetry(messages, retry, toolName) {
+  messages.push({
+    role: "assistant",
+    content: [{
+      type: "tool_use",
+      id: RETRY_TOOL_USE_ID,
+      name: toolName,
+      input: retry.previousOutput
+    }]
+  });
+  messages.push({
+    role: "user",
+    content: [{
+      type: "tool_result",
+      tool_use_id: RETRY_TOOL_USE_ID,
+      content: retry.feedback
+    }]
+  });
+}
+async function generateText(input) {
+  const messages = buildUserMessages(input.prompt);
+  const opts = input.maxTokens !== void 0 ? { maxTokens: input.maxTokens } : {};
+  const response = input.onProgress ? await callStream(messages, input.system, opts, input.signal, input.onProgress) : await call(messages, input.system, opts, input.signal);
+  return response.content.filter((b) => b.type === "text").map((b) => b.text).join("");
+}
+async function generateObject(input) {
+  const toolName = input.objectName ?? "structured_output";
+  const structuredParams = JSONSchema.make(input.schema);
+  const helperTools = input.tools ?? [];
+  const helperByName = new Map(helperTools.map((t) => [t.name, t]));
+  const tools = [
+    ...helperTools.map((t) => ({
+      name: t.name,
+      description: t.description,
+      input_schema: t.inputJsonSchema
+    })),
+    {
+      name: toolName,
+      description: "Return the structured output as the tool input.",
+      input_schema: structuredParams
     }
-    return await res.json();
-  }
-  async function callStream(messages, options, signal, onProgress) {
-    const body = { ...buildBody(messages, options), stream: true };
-    const res = await fetch(endpoint, buildInit(body, signal));
-    if (!res.ok) {
-      throw new Error(`OpenAI ${res.status}: ${await readError(res) || res.statusText}`);
+  ];
+  const toolChoice = helperTools.length > 0 ? { type: "any" } : { type: "tool", name: toolName };
+  const messages = buildUserMessages(input.prompt);
+  if (input.retry) appendRetry(messages, input.retry, toolName);
+  const opts = {
+    tools,
+    toolChoice,
+    ...input.maxTokens !== void 0 ? { maxTokens: input.maxTokens } : {}
+  };
+  const decode = (raw) => {
+    try {
+      return Schema.decodeUnknownSync(input.schema)(raw);
+    } catch (cause) {
+      throw new StructuredOutputDecodeError(raw, cause);
     }
-    let content = "";
-    const tools = /* @__PURE__ */ new Map();
-    let finishReason;
-    for await (const ev of readSSE(res)) {
-      if (ev.data === "[DONE]") break;
-      let chunk;
-      try {
-        chunk = JSON.parse(ev.data);
-      } catch {
-        continue;
-      }
-      const choice = chunk.choices?.[0];
-      if (!choice) continue;
-      if (choice.finish_reason) finishReason = choice.finish_reason;
-      const delta = choice.delta;
-      if (!delta) continue;
-      if (delta.content) {
-        content += delta.content;
-        onProgress();
-      }
-      if (delta.tool_calls) {
-        for (const tc of delta.tool_calls) {
-          const idx = tc.index ?? 0;
-          const cur = tools.get(idx) ?? { arguments: "" };
-          if (tc.id) cur.id = tc.id;
-          if (tc.function?.name) cur.name = tc.function.name;
-          if (tc.function?.arguments) {
-            cur.arguments += tc.function.arguments;
-            onProgress();
-          }
-          tools.set(idx, cur);
-        }
+  };
+  for (; ; ) {
+    const response = input.onProgress ? await callStream(messages, input.system, opts, input.signal, input.onProgress) : await call(messages, input.system, opts, input.signal);
+    const toolUses = response.content.filter(
+      (b) => b.type === "tool_use"
+    );
+    const structured = toolUses.find((c) => c.name === toolName);
+    if (structured) {
+      return decode(structured.input);
+    }
+    if (toolUses.length === 0) {
+      if (response.stop_reason === "max_tokens") {
+        throw new Error("\u6A21\u578B\u5728\u4EA7\u51FA\u7ED3\u6784\u5316\u7ED3\u679C\u524D\u7528\u5C3D\u4E86 token \u9884\u7B97\uFF08stop_reason=max_tokens\uFF09\u3002\u8BF7\u63D0\u9AD8 maxTokens\uFF0C\u6216\u6362\u7528\u975E\u63A8\u7406\u6A21\u578B\u3002");
       }
+      const text = response.content.filter((b) => b.type === "text").map((b) => b.text).join("");
+      const reason = response.stop_reason ? `\uFF08stop_reason=${response.stop_reason}\uFF09` : "";
+      throw new Error(`\u6A21\u578B\u672A\u8FD4\u56DE\u7ED3\u6784\u5316\u8F93\u51FA${reason}${text ? `: ${text.slice(0, 200)}` : ""}`);
     }
-    const toolCalls = [...tools.entries()].sort(([a], [b]) => a - b).map(([, v]) => ({
-      id: v.id ?? "",
-      type: "function",
-      function: { name: v.name ?? "", arguments: v.arguments }
-    }));
-    return {
-      choices: [{
-        finish_reason: finishReason,
-        message: {
-          content: content || null,
-          ...toolCalls.length > 0 ? { tool_calls: toolCalls } : {}
-        }
-      }]
-    };
-  }
-  const RETRY_TOOL_CALL_ID = "retry_call_0";
-  function buildMessages(prompt, system) {
-    const messages = [];
-    if (system !== void 0) messages.push({ role: "system", content: system });
-    messages.push({ role: "user", content: prompt });
-    return messages;
-  }
-  function appendRetry(messages, retry, toolName) {
     messages.push({
       role: "assistant",
-      content: null,
-      tool_calls: [{
-        id: RETRY_TOOL_CALL_ID,
-        type: "function",
-        function: { name: toolName, arguments: JSON.stringify(retry.previousOutput) }
-      }]
-    });
-    messages.push({
-      role: "tool",
-      tool_call_id: RETRY_TOOL_CALL_ID,
-      content: retry.feedback
+      content: toolUses
     });
-  }
-  return {
-    async generateText(input) {
-      const messages = buildMessages(input.prompt, input.system);
-      const opts = input.maxTokens !== void 0 ? { maxTokens: input.maxTokens } : {};
-      const response = input.onProgress ? await callStream(messages, opts, input.signal, input.onProgress) : await call(messages, opts, input.signal);
-      return response.choices[0]?.message.content ?? "";
-    },
-    async generateObject(input) {
-      const toolName = input.objectName ?? "structured_output";
-      const structuredParams = JSONSchema.make(input.schema);
-      const helperTools = input.tools ?? [];
-      const helperByName = new Map(helperTools.map((t) => [t.name, t]));
-      const tools = [
-        ...helperTools.map((t) => ({
-          type: "function",
-          function: {
-            name: t.name,
-            description: t.description,
-            parameters: t.inputJsonSchema
-          }
-        })),
-        {
-          type: "function",
-          function: {
-            name: toolName,
-            description: "Return the structured output as the function arguments.",
-            parameters: structuredParams
-          }
-        }
-      ];
-      const toolChoice = helperTools.length > 0 ? "required" : { type: "function", function: { name: toolName } };
-      const messages = buildMessages(input.prompt, input.system);
-      if (input.retry) appendRetry(messages, input.retry, toolName);
-      const opts = {
-        tools,
-        toolChoice,
-        ...input.maxTokens !== void 0 ? { maxTokens: input.maxTokens } : {}
-      };
-      const decodeArgs = (raw) => {
-        try {
-          return JSON.parse(raw);
-        } catch (err) {
-          const message = err instanceof Error ? err.message : String(err);
-          throw new Error(`\u65E0\u6CD5\u89E3\u6790\u6A21\u578B\u8FD4\u56DE\u7684\u7ED3\u6784\u5316\u6570\u636E: ${message}`);
-        }
-      };
-      const decode = (raw) => {
-        try {
-          return Schema.decodeUnknownSync(input.schema)(raw);
-        } catch (cause) {
-          throw new StructuredOutputDecodeError(raw, cause);
-        }
-      };
-      for (; ; ) {
-        const response = input.onProgress ? await callStream(messages, opts, input.signal, input.onProgress) : await call(messages, opts, input.signal);
-        const choice = response.choices[0];
-        const structured = choice?.message.tool_calls?.find((c) => c.function.name === toolName);
-        if (structured) {
-          return decode(decodeArgs(structured.function.arguments));
-        }
-        const helperCalls = choice?.message.tool_calls ?? [];
-        if (helperCalls.length === 0) {
-          if (choice?.finish_reason === "length") {
-            throw new Error("\u6A21\u578B\u5728\u4EA7\u51FA\u7ED3\u6784\u5316\u7ED3\u679C\u524D\u7528\u5C3D\u4E86 token \u9884\u7B97\uFF08finish_reason=length\uFF09\u3002\u8BF7\u63D0\u9AD8 maxTokens\uFF0C\u6216\u6362\u7528\u975E\u63A8\u7406\u6A21\u578B\u3002");
-          }
-          const text = choice?.message.content ?? "";
-          const reason = choice?.finish_reason ? `\uFF08finish_reason=${choice.finish_reason}\uFF09` : "";
-          throw new Error(`\u6A21\u578B\u672A\u8FD4\u56DE\u7ED3\u6784\u5316\u8F93\u51FA${reason}${text ? `: ${text.slice(0, 200)}` : ""}`);
-        }
-        messages.push({
-          role: "assistant",
-          content: null,
-          tool_calls: helperCalls
+    const results = [];
+    for (const useBlock of toolUses) {
+      const tool = helperByName.get(useBlock.name);
+      if (!tool) {
+        results.push({
+          type: "tool_result",
+          tool_use_id: useBlock.id,
+          content: `Unknown tool: ${useBlock.name}`
+        });
+        continue;
+      }
+      try {
+        const result = await tool.execute(useBlock.input ?? {});
+        results.push({
+          type: "tool_result",
+          tool_use_id: useBlock.id,
+          content: typeof result === "string" ? result : JSON.stringify(result)
+        });
+      } catch (err) {
+        results.push({
+          type: "tool_result",
+          tool_use_id: useBlock.id,
+          content: err instanceof Error ? err.message : String(err)
         });
-        for (const callBlock of helperCalls) {
-          const tool = helperByName.get(callBlock.function.name);
-          if (!tool) {
-            messages.push({
-              role: "tool",
-              tool_call_id: callBlock.id,
-              content: `Unknown tool: ${callBlock.function.name}`
-            });
-            continue;
-          }
-          let parsedInput = {};
-          try {
-            parsedInput = callBlock.function.arguments ? JSON.parse(callBlock.function.arguments) : {};
-          } catch {
-          }
-          try {
-            const result = await tool.execute(parsedInput);
-            messages.push({
-              role: "tool",
-              tool_call_id: callBlock.id,
-              content: typeof result === "string" ? result : JSON.stringify(result)
-            });
-          } catch (err) {
-            messages.push({
-              role: "tool",
-              tool_call_id: callBlock.id,
-              content: err instanceof Error ? err.message : String(err)
-            });
-          }
-        }
       }
     }
-  };
-}
-function buildClient(cfg) {
-  switch (cfg.provider) {
-    case "anthropic":
-      return buildAnthropicClient(cfg);
-    case "openai":
-      return buildOpenAIClient(cfg);
-    default:
-      throw new Error(`unsupported AI provider: ${cfg.provider}`);
+    messages.push({ role: "user", content: results });
   }
 }
 export default defineNuxtPlugin({
   name: "shwfed:ai",
   setup: () => {
-    const config = createConfigRef();
-    const allowed = isByokAllowed();
-    const available = computed(() => allowed && config.value !== null);
-    function setConfig(next) {
-      config.value = next;
-    }
-    function openSettings() {
-      settingsOpen.value = true;
-    }
-    async function generateText(input) {
-      const cfg = config.value;
-      if (!cfg) throw new Error("AI \u672A\u914D\u7F6E");
-      return buildClient(cfg).generateText(input);
-    }
-    async function generateObject(input) {
-      const cfg = config.value;
-      if (!cfg) throw new Error("AI \u672A\u914D\u7F6E");
-      return buildClient(cfg).generateObject(input);
-    }
     const ai = {
-      available,
-      config,
-      setConfig,
-      openSettings,
+      available: computed(() => true),
       generateText,
       generateObject
     };