@yh-ui/ai-sdk 0.1.21

package/dist/future.cjs

@@ -0,0 +1,882 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createAudioContent = createAudioContent;
+exports.createChainOfThought = createChainOfThought;
+exports.createContextCompressor = createContextCompressor;
+exports.createCostTracker = createCostTracker;
+exports.createImageContent = createImageContent;
+exports.createImageUrlContent = createImageUrlContent;
+exports.createJSONSchema = createJSONSchema;
+exports.createMultiModalMessage = createMultiModalMessage;
+exports.createPlanExecuteAgent = createPlanExecuteAgent;
+exports.createRAGSystem = createRAGSystem;
+exports.createSafetyFilter = createSafetyFilter;
+exports.createTracer = createTracer;
+exports.createVideoContent = createVideoContent;
+exports.fromZodSchema = fromZodSchema;
+exports.parseStructuredOutput = parseStructuredOutput;
+exports.schema = void 0;
+exports.useReActAgent = useReActAgent;
+var _vue = require("vue");
+function useReActAgent(config) {
+  const {
+    type: _type = "react",
+    maxIterations = 10,
+    maxToolCalls = 20,
+    returnReasoning = false,
+    tools = [],
+    stopConditions = [],
+    onError
+  } = config;
+  const steps = (0, _vue.ref)([]);
+  const isRunning = (0, _vue.ref)(false);
+  const currentOutput = (0, _vue.ref)("");
+  const toolCallCount = (0, _vue.ref)(0);
+  const addStep = step => {
+    steps.value.push({
+      ...step,
+      id: `step-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+      timestamp: /* @__PURE__ */new Date()
+    });
+  };
+  const checkStopConditions = output => {
+    for (const condition of stopConditions) {
+      switch (condition.type) {
+        case "contains":
+          if (condition.value && output.includes(condition.value)) {
+            return true;
+          }
+          break;
+        case "custom":
+          if (condition.value && condition.value(output)) {
+            return true;
+          }
+          break;
+      }
+    }
+    return false;
+  };
+  const executeTool = async (toolName, args) => {
+    const tool = tools.find(t => t.name === toolName);
+    if (!tool) {
+      throw new Error(`Tool not found: ${toolName}`);
+    }
+    addStep({
+      type: "action",
+      content: `Executing tool: ${toolName}`,
+      toolName,
+      toolInput: args
+    });
+    try {
+      const result = await tool.execute(args);
+      const resultStr = typeof result === "string" ? result : JSON.stringify(result);
+      addStep({
+        type: "observation",
+        content: resultStr,
+        toolName,
+        toolOutput: result
+      });
+      toolCallCount.value++;
+      return resultStr;
+    } catch (error) {
+      addStep({
+        type: "observation",
+        content: `Error: ${error instanceof Error ? error.message : String(error)}`,
+        toolName,
+        toolOutput: error
+      });
+      throw error;
+    }
+  };
+  const parseResponse = response => {
+    const thoughtMatch = response.match(/Thought:?\s*(.+)/i);
+    const actionMatch = response.match(/Action:?\s*(.+)/i);
+    const actionInputMatch = response.match(/Action Input:?\s*(.+)/i);
+    return {
+      thought: thoughtMatch ? thoughtMatch[1].trim() : response,
+      action: actionMatch ? actionMatch[1].trim() : void 0,
+      actionInput: actionInputMatch ? actionInputMatch[1].trim() : void 0
+    };
+  };
+  const run = async (input, executeFn) => {
+    if (isRunning.value) {
+      throw new Error("Agent is already running");
+    }
+    isRunning.value = true;
+    steps.value = [];
+    currentOutput.value = "";
+    toolCallCount.value = 0;
+    let iteration = 0;
+    let context = `Task: ${input}
+
+`;
+    try {
+      while (iteration < maxIterations && toolCallCount.value < maxToolCalls) {
+        iteration++;
+        if (checkStopConditions(currentOutput.value)) {
+          break;
+        }
+        addStep({
+          type: "thought",
+          content: `Iteration ${iteration}: Thinking about how to proceed...`
+        });
+        const response = await executeFn(context);
+        const parsed = parseResponse(response);
+        currentOutput.value = parsed.thought;
+        if (parsed.action && parsed.actionInput) {
+          try {
+            const observation = await executeTool(parsed.action, JSON.parse(parsed.actionInput));
+            context += `Thought: ${parsed.thought}
+Action: ${parsed.action}
+Action Input: ${parsed.actionInput}
+Observation: ${observation}
+
+`;
+          } catch (error) {
+            context += `Thought: ${parsed.thought}
+Action: ${parsed.action}
+Action Input: ${parsed.actionInput}
+Observation: Error - ${error instanceof Error ? error.message : String(error)}
+
+`;
+            if (onError) {
+              await onError(error, steps.value[steps.value.length - 1]);
+            }
+          }
+        } else {
+          addStep({
+            type: "result",
+            content: parsed.thought
+          });
+          break;
+        }
+      }
+      return {
+        output: currentOutput.value,
+        reasoning: returnReasoning ? steps.value : void 0,
+        toolCalls: toolCallCount.value,
+        finished: iteration >= maxIterations
+      };
+    } catch (error) {
+      return {
+        output: currentOutput.value,
+        reasoning: returnReasoning ? steps.value : void 0,
+        toolCalls: toolCallCount.value,
+        finished: false,
+        error: error instanceof Error ? error : new Error(String(error))
+      };
+    } finally {
+      isRunning.value = false;
+    }
+  };
+  return {
+    steps,
+    isRunning,
+    currentOutput,
+    toolCallCount,
+    run
+  };
+}
+function createPlanExecuteAgent(config) {
+  const {
+    tools = []
+  } = config;
+  const plans = (0, _vue.ref)([]);
+  const currentPlan = (0, _vue.ref)(null);
+  const results = (0, _vue.ref)({});
+  const executeTool = async (toolName, args) => {
+    const tool = tools.find(t => t.name === toolName);
+    if (!tool) {
+      throw new Error(`Tool not found: ${toolName}`);
+    }
+    return tool.execute(args);
+  };
+  const execute = async (task, llm) => {
+    const planPrompt = `\u5206\u89E3\u4EE5\u4E0B\u4EFB\u52A1\u4E3A\u591A\u4E2A\u53EF\u6267\u884C\u7684\u6B65\u9AA4\uFF0C\u8FD4\u56DE JSON \u6570\u7EC4\u683C\u5F0F\uFF1A
+    [{"step": "\u6B65\u9AA4\u63CF\u8FF0", "tool": "\u5DE5\u5177\u540D", "input": {"\u53C2\u6570": "\u503C"}}]
+    
+    \u4EFB\u52A1: ${task}
+    
+    \u53EF\u7528\u5DE5\u5177: ${tools.map(t => t.name).join(", ")}`;
+    const planResponse = await llm(planPrompt);
+    try {
+      const parsed = JSON.parse(planResponse.replace(/```json|```/g, "").trim());
+      plans.value = parsed.map((p, i) => ({
+        id: `plan-${i}`,
+        description: p.step,
+        status: "pending"
+      }));
+    } catch {
+      plans.value = [{
+        id: "plan-0",
+        description: planResponse,
+        status: "pending"
+      }];
+    }
+    for (const plan of plans.value) {
+      currentPlan.value = plan.id;
+      plan.status = "pending";
+      try {
+        const execPrompt = `\u6839\u636E\u5F53\u524D\u6B65\u9AA4\u751F\u6210\u5DE5\u5177\u8C03\u7528\uFF1A
+        
+        \u6B65\u9AA4: ${plan.description}
+        \u4E0A\u4E0B\u6587: ${JSON.stringify(results.value)}
+        
+        \u8FD4\u56DE\u683C\u5F0F: {"tool": "\u5DE5\u5177\u540D", "input": {"\u53C2\u6570": "\u503C"}}`;
+        const execResponse = await llm(execPrompt);
+        const exec = JSON.parse(execResponse.replace(/```json|```/g, "").trim());
+        if (exec.tool) {
+          const result = await executeTool(exec.tool, exec.input || {});
+          results.value[plan.id] = result;
+          plan.status = "completed";
+        } else {
+          results.value[plan.id] = execResponse;
+          plan.status = "completed";
+        }
+      } catch (error) {
+        plan.status = "failed";
+        results.value[plan.id] = {
+          error: error instanceof Error ? error.message : String(error)
+        };
+      }
+    }
+    const summaryPrompt = `\u6839\u636E\u4EE5\u4E0B\u6267\u884C\u7ED3\u679C\uFF0C\u7528\u81EA\u7136\u8BED\u8A00\u603B\u7ED3\u56DE\u7B54\u7528\u6237\uFF1A
+    
+    \u4EFB\u52A1: ${task}
+    \u6267\u884C\u7ED3\u679C: ${JSON.stringify(results.value)}
+    
+    \u8BF7\u7528\u4E2D\u6587\u56DE\u7B54\uFF1A`;
+    const finalResult = await llm(summaryPrompt);
+    return {
+      result: finalResult,
+      plan: plans.value,
+      results: results.value
+    };
+  };
+  return {
+    plans,
+    currentPlan,
+    results,
+    execute
+  };
+}
+function createMultiModalMessage(role, contents) {
+  return {
+    role,
+    content: contents
+  };
+}
+function createImageContent(source, value, mimeType) {
+  return {
+    type: "image",
+    ...(source === "url" ? {
+      url: value
+    } : {
+      base64: value
+    }),
+    mimeType: mimeType || (source === "base64" ? "image/png" : void 0)
+  };
+}
+function createImageUrlContent(url, detail) {
+  return {
+    type: "image_url",
+    url,
+    mimeType: detail
+  };
+}
+function createAudioContent(base64, mimeType = "audio/m4a") {
+  return {
+    type: "audio",
+    base64,
+    mimeType
+  };
+}
+function createVideoContent(base64, mimeType = "video/mp4") {
+  return {
+    type: "video",
+    base64,
+    mimeType
+  };
+}
+function createRAGSystem(config) {
+  const {
+    knowledgeBaseId,
+    topK = 3,
+    similarityThreshold = 0.5,
+    includeSources = true,
+    strategy = "similarity"
+  } = config;
+  const vectorStore = /* @__PURE__ */new Map();
+  const addDocuments = async documents => {
+    const chunks = documents.map((doc, i) => ({
+      id: `chunk-${Date.now()}-${i}`,
+      content: doc.content,
+      metadata: doc.metadata || {},
+      // 简化：实际应该调用 embedding API
+      score: Math.random()
+    }));
+    if (knowledgeBaseId) {
+      const existing = vectorStore.get(knowledgeBaseId) || [];
+      vectorStore.set(knowledgeBaseId, [...existing, ...chunks]);
+    }
+    return chunks;
+  };
+  const retrieve = async (query2, k = topK) => {
+    if (!knowledgeBaseId) return [];
+    const chunks = vectorStore.get(knowledgeBaseId) || [];
+    const sorted = [...chunks].sort((a, b) => (b.score || 0) - (a.score || 0)).slice(0, k);
+    return sorted.filter(c => (c.score || 0) >= similarityThreshold);
+  };
+  const query = async (question, llm) => {
+    const relevantDocs = await retrieve(question);
+    if (relevantDocs.length === 0) {
+      return {
+        answer: "\u62B1\u6B49\uFF0C\u77E5\u8BC6\u5E93\u4E2D\u6CA1\u6709\u627E\u5230\u76F8\u5173\u4FE1\u606F\u3002",
+        sources: [],
+        contextUsed: ""
+      };
+    }
+    const context = relevantDocs.map((doc, i) => `[\u6587\u6863 ${i + 1}]
+${doc.content}`).join("\n\n");
+    const prompt = `\u57FA\u4E8E\u4EE5\u4E0B\u77E5\u8BC6\u5E93\u5185\u5BB9\uFF0C\u7528\u4E2D\u6587\u56DE\u7B54\u7528\u6237\u7684\u95EE\u9898\u3002\u5982\u679C\u77E5\u8BC6\u5E93\u4E2D\u7684\u4FE1\u606F\u4E0D\u80FD\u56DE\u7B54\u95EE\u9898\uFF0C\u8BF7\u8BF4\u660E\u3002
+
+\u77E5\u8BC6\u5E93\u5185\u5BB9:
+${context}
+
+\u7528\u6237\u95EE\u9898: ${question}
+
+\u8BF7\u7ED9\u51FA\u56DE\u7B54\uFF1A`;
+    const answer = await llm(prompt);
+    return {
+      answer,
+      sources: includeSources ? relevantDocs.map(doc => ({
+        content: doc.content.slice(0, 200) + "...",
+        metadata: doc.metadata,
+        score: doc.score || 0
+      })) : [],
+      contextUsed: context.slice(0, 500)
+    };
+  };
+  const clear = () => {
+    if (knowledgeBaseId) {
+      vectorStore.delete(knowledgeBaseId);
+    }
+  };
+  return {
+    addDocuments,
+    retrieve,
+    query,
+    clear,
+    config: {
+      topK,
+      similarityThreshold,
+      strategy
+    }
+  };
+}
+function createChainOfThought(config = {
+  mode: "standard"
+}) {
+  const {
+    mode = "standard",
+    maxDepth = 5,
+    showConfidence = false
+  } = config;
+  const reasoningSteps = (0, _vue.ref)([]);
+  const think = async (problem, llm) => {
+    reasoningSteps.value = [];
+    const prompt = mode === "standard" ? `\u9010\u6B65\u601D\u8003\u5E76\u7ED9\u51FA\u7B54\u6848\uFF1A${problem}` : mode === "chain" ? `\u6309\u6B65\u9AA4\u5206\u6790\uFF1A${problem}` : mode === "tree" ? `\u7528\u6811\u72B6\u7ED3\u6784\u5206\u6790\uFF1A${problem}` : `\u7528\u8868\u683C\u5F62\u5F0F\u5206\u6790\uFF1A${problem}`;
+    const response = await llm(prompt);
+    const lines = response.split("\n").filter(l => l.trim());
+    reasoningSteps.value = lines.map((line, i) => ({
+      id: `reason-${i}`,
+      content: line.replace(/^\d+[.)：:、]\s*/, ""),
+      type: i === lines.length - 1 ? "conclusion" : "analysis"
+    }));
+    return {
+      result: response,
+      reasoning: reasoningSteps.value
+    };
+  };
+  const addStep = step => {
+    reasoningSteps.value.push({
+      ...step,
+      id: `reason-${Date.now()}-${Math.random().toString(36).slice(2)}`
+    });
+  };
+  const clear = () => {
+    reasoningSteps.value = [];
+  };
+  return {
+    think,
+    addStep,
+    clear,
+    reasoningSteps,
+    config: {
+      mode,
+      maxDepth,
+      showConfidence
+    }
+  };
+}
+function createContextCompressor(config) {
+  const {
+    strategy = "summary",
+    targetTokens = 2e3,
+    preserveKeyInfo = []
+  } = config;
+  const estimateTokens = text => Math.ceil(text.length / 4);
+  const compress = async (content, llm) => {
+    const isArray = Array.isArray(content);
+    const text = isArray ? content.map(m => `${m.role}: ${m.content}`).join("\n") : content;
+    const originalTokens = estimateTokens(text);
+    if (originalTokens <= targetTokens) {
+      return {
+        compressedContent: text,
+        originalTokens,
+        compressedTokens: originalTokens,
+        compressionRatio: 1,
+        extractedKeyInfo: preserveKeyInfo
+      };
+    }
+    let compressed;
+    switch (strategy) {
+      case "summary":
+        {
+          if (!llm) {
+            const ratio = targetTokens / originalTokens;
+            compressed = text.slice(0, Math.floor(text.length * ratio));
+          } else {
+            const summaryPrompt = `\u5C06\u4EE5\u4E0B\u5185\u5BB9\u538B\u7F29\u5230\u7EA6 ${targetTokens} \u5B57\u7B26\uFF0C\u4FDD\u7559\u5173\u952E\u4FE1\u606F\uFF1A
+          
+          ${text}`;
+            compressed = await llm(summaryPrompt);
+          }
+          break;
+        }
+      case "extract":
+        {
+          const sentences = text.split(/[。！？\n]/).filter(s => s.trim());
+          const keySentences = sentences.slice(0, Math.floor(sentences.length * (targetTokens / originalTokens)));
+          compressed = keySentences.join("\u3002") + "\u3002";
+          break;
+        }
+      case "prune":
+        {
+          const lines = text.split("\n");
+          const seen = /* @__PURE__ */new Set();
+          const pruned = lines.filter(line => {
+            const key = line.slice(0, 50);
+            if (seen.has(key)) return false;
+            seen.add(key);
+            return true;
+          });
+          compressed = pruned.join("\n").slice(0, targetTokens * 4);
+          break;
+        }
+      default:
+        compressed = text.slice(0, targetTokens * 4);
+    }
+    const compressedTokens = estimateTokens(compressed);
+    return {
+      compressedContent: compressed,
+      originalTokens,
+      compressedTokens,
+      compressionRatio: compressedTokens / originalTokens,
+      extractedKeyInfo: preserveKeyInfo
+    };
+  };
+  return {
+    compress,
+    estimateTokens,
+    config: {
+      strategy,
+      targetTokens,
+      preserveKeyInfo
+    }
+  };
+}
+function createCostTracker(config = {}) {
+  const {
+    monthlyBudget = 100,
+    maxTokensPerRequest = 1e5,
+    warningThreshold = 0.8
+  } = config;
+  const dailyUsage = {};
+  const totalUsage = {
+    prompt: 0,
+    completion: 0,
+    total: 0
+  };
+  const PRICING = {
+    "gpt-4": {
+      prompt: 30,
+      completion: 60
+    },
+    "gpt-4-turbo": {
+      prompt: 10,
+      completion: 30
+    },
+    "gpt-3.5-turbo": {
+      prompt: 0.5,
+      completion: 1.5
+    },
+    "claude-3-opus": {
+      prompt: 15,
+      completion: 75
+    },
+    "claude-3-sonnet": {
+      prompt: 3,
+      completion: 15
+    },
+    "gemini-pro": {
+      prompt: 0.5,
+      completion: 1.5
+    }
+  };
+  const track = (usage, _model = "gpt-4") => {
+    const today = (/* @__PURE__ */new Date()).toISOString().split("T")[0];
+    if (!dailyUsage[today]) {
+      dailyUsage[today] = {
+        prompt: 0,
+        completion: 0
+      };
+    }
+    dailyUsage[today].prompt += usage.prompt;
+    dailyUsage[today].completion += usage.completion;
+    totalUsage.prompt += usage.prompt;
+    totalUsage.completion += usage.completion;
+    totalUsage.total += usage.prompt + usage.completion;
+  };
+  const calculateCost = (usage, model) => {
+    const pricing = PRICING[model] || PRICING["gpt-4"];
+    return pricing.prompt * usage.prompt / 1e6 + pricing.completion * usage.completion / 1e6;
+  };
+  const getStatus = () => {
+    const totalCost = calculateCost(totalUsage, "gpt-4");
+    const budgetRemaining = monthlyBudget - totalCost;
+    return {
+      totalCost,
+      dailyCost: Object.fromEntries(Object.entries(dailyUsage).map(([date, usage]) => [date, calculateCost({
+        prompt: usage.prompt,
+        completion: usage.completion,
+        total: 0
+      }, "gpt-4")])),
+      usage: {
+        ...totalUsage
+      },
+      budget: {
+        monthlyBudget,
+        warningThreshold
+      },
+      remaining: budgetRemaining
+    };
+  };
+  const isOverBudget = () => {
+    const status = getStatus();
+    return status.remaining < 0;
+  };
+  const shouldWarn = () => {
+    const status = getStatus();
+    return status.totalCost >= monthlyBudget * warningThreshold;
+  };
+  const checkRequestLimit = tokens => {
+    if (tokens > maxTokensPerRequest) {
+      return {
+        allowed: false,
+        reason: `\u8BF7\u6C42 token \u6570 ${tokens} \u8D85\u8FC7\u9650\u5236 ${maxTokensPerRequest}`
+      };
+    }
+    const status = getStatus();
+    const estimatedCost = tokens / 1e6 * 30;
+    if (status.remaining - estimatedCost < 0) {
+      return {
+        allowed: false,
+        reason: "\u9884\u7B97\u4E0D\u8DB3"
+      };
+    }
+    return {
+      allowed: true
+    };
+  };
+  const reset = () => {
+    Object.keys(dailyUsage).forEach(key => delete dailyUsage[key]);
+    totalUsage.prompt = 0;
+    totalUsage.completion = 0;
+    totalUsage.total = 0;
+  };
+  return {
+    track,
+    calculateCost,
+    getStatus,
+    isOverBudget,
+    shouldWarn,
+    checkRequestLimit,
+    reset,
+    pricing: PRICING,
+    config: {
+      monthlyBudget,
+      maxTokensPerRequest,
+      warningThreshold
+    }
+  };
+}
+function createTracer() {
+  const spans = (0, _vue.ref)([]);
+  const events = (0, _vue.ref)([]);
+  const activeSpans = /* @__PURE__ */new Map();
+  const startSpan = (name, attributes = {}) => {
+    const id = `span-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+    const span = {
+      id,
+      name,
+      startTime: /* @__PURE__ */new Date(),
+      events: [],
+      attributes,
+      children: []
+    };
+    spans.value.push(span);
+    activeSpans.set(id, span);
+    addEvent({
+      type: "custom",
+      data: {
+        action: "span_start",
+        name
+      }
+    });
+    return id;
+  };
+  const endSpan = (id, attributes = {}) => {
+    const span = activeSpans.get(id);
+    if (span) {
+      span.endTime = /* @__PURE__ */new Date();
+      span.attributes = {
+        ...span.attributes,
+        ...attributes
+      };
+      activeSpans.delete(id);
+      addEvent({
+        type: "custom",
+        data: {
+          action: "span_end",
+          name: span.name,
+          duration: span.endTime.getTime() - span.startTime.getTime()
+        }
+      });
+    }
+  };
+  const addEvent = event => {
+    events.value.push({
+      ...event,
+      id: `event-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+      timestamp: /* @__PURE__ */new Date()
+    });
+  };
+  const recordRequest = (config, spanId) => {
+    const event = {
+      id: `req-${Date.now()}`,
+      type: "request",
+      timestamp: /* @__PURE__ */new Date(),
+      data: config,
+      parentId: spanId
+    };
+    events.value.push(event);
+  };
+  const recordResponse = (response, duration, spanId) => {
+    const event = {
+      id: `res-${Date.now()}`,
+      type: "response",
+      timestamp: /* @__PURE__ */new Date(),
+      data: {
+        response,
+        duration
+      },
+      parentId: spanId
+    };
+    events.value.push(event);
+  };
+  const recordError = (error, context, spanId) => {
+    const event = {
+      id: `err-${Date.now()}`,
+      type: "error",
+      timestamp: /* @__PURE__ */new Date(),
+      data: {
+        message: error.message,
+        stack: error.stack,
+        ...context
+      },
+      parentId: spanId
+    };
+    events.value.push(event);
+  };
+  const getEvents = () => events.value;
+  const getSpans = () => spans.value;
+  const clear = () => {
+    spans.value = [];
+    events.value = [];
+    activeSpans.clear();
+  };
+  const exportJSON = () => JSON.stringify({
+    spans: spans.value,
+    events: events.value
+  }, null, 2);
+  return {
+    startSpan,
+    endSpan,
+    addEvent,
+    recordRequest,
+    recordResponse,
+    recordError,
+    getEvents,
+    getSpans,
+    clear,
+    exportJSON
+  };
+}
+function createSafetyFilter(config) {
+  const {
+    rules = []
+  } = config;
+  const check = async content => {
+    const violations = [];
+    for (const rule of rules) {
+      let passed = true;
+      let replacedContent = content;
+      if (rule.pattern) {
+        const regex = typeof rule.pattern === "string" ? new RegExp(rule.pattern, "gi") : rule.pattern;
+        passed = !regex.test(content);
+        replacedContent = content.replace(regex, "***");
+      }
+      if (rule.customCheck && passed) {
+        passed = !(await rule.customCheck(content));
+      }
+      if (!passed) {
+        violations.push({
+          rule,
+          content,
+          action: rule.action === "replace" && replacedContent !== content ? "replaced" : rule.action === "block" ? "blocked" : "warned",
+          replacedContent: rule.action === "replace" ? replacedContent : void 0
+        });
+        if (rule.action === "block") {
+          break;
+        }
+      }
+    }
+    return {
+      passed: violations.length === 0 || violations.every(v => v.action !== "blocked"),
+      violations
+    };
+  };
+  const addRule = rule => {
+    rules.push(rule);
+  };
+  const removeRule = ruleId => {
+    const index = rules.findIndex(r => r.id === ruleId);
+    if (index > -1) {
+      rules.splice(index, 1);
+    }
+  };
+  const createPresetRules = type => {
+    const presets = {
+      strict: [{
+        id: "s1",
+        name: "\u653F\u6CBB\u654F\u611F",
+        type: "content_filter",
+        pattern: "\u653F\u6CBB|\u9886\u5BFC\u4EBA",
+        action: "block"
+      }, {
+        id: "s2",
+        name: "\u66B4\u529B\u5185\u5BB9",
+        type: "content_filter",
+        pattern: "\u66B4\u529B|\u8840\u8165",
+        action: "block"
+      }, {
+        id: "s3",
+        name: "\u6076\u610F\u8F6F\u4EF6",
+        type: "content_filter",
+        pattern: "\u75C5\u6BD2|\u6728\u9A6C",
+        action: "block"
+      }],
+      moderate: [{
+        id: "m1",
+        name: "\u653F\u6CBB\u654F\u611F",
+        type: "content_filter",
+        pattern: "\u653F\u6CBB|\u9886\u5BFC\u4EBA",
+        action: "warn"
+      }, {
+        id: "m2",
+        name: "\u66B4\u529B\u5185\u5BB9",
+        type: "content_filter",
+        pattern: "\u66B4\u529B|\u8840\u8165",
+        action: "warn"
+      }],
+      lenient: [{
+        id: "l1",
+        name: "\u6076\u610F\u5185\u5BB9",
+        type: "content_filter",
+        pattern: "\u75C5\u6BD2|\u6728\u9A6C",
+        action: "block"
+      }]
+    };
+    rules.push(...presets[type]);
+  };
+  return {
+    check,
+    addRule,
+    removeRule,
+    createPresetRules,
+    rules
+  };
+}
+function fromZodSchema(schema2) {
+  return {
+    type: "object",
+    schema: schema2,
+    toJSONSchema: () => schema2
+  };
+}
+function createJSONSchema(definition) {
+  return definition;
+}
+const schema = exports.schema = {
+  string: description => ({
+    type: "string",
+    description
+  }),
+  number: description => ({
+    type: "number",
+    description
+  }),
+  boolean: description => ({
+    type: "boolean",
+    description
+  }),
+  enum: (values, description) => ({
+    type: "string",
+    enum: values,
+    description
+  }),
+  array: items => ({
+    type: "array",
+    items
+  }),
+  object: (properties, required = []) => ({
+    type: "object",
+    properties,
+    required
+  })
+};
+function parseStructuredOutput(output, _schema) {
+  try {
+    const jsonMatch = output.match(/\{[\s\S]*\}/);
+    if (jsonMatch) {
+      return JSON.parse(jsonMatch[0]);
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}