@yh-ui/ai-sdk 0.1.21

package/dist/future.mjs

@@ -0,0 +1,765 @@
+import { ref } from "vue";
+export function useReActAgent(config) {
+  const {
+    type: _type = "react",
+    maxIterations = 10,
+    maxToolCalls = 20,
+    returnReasoning = false,
+    tools = [],
+    stopConditions = [],
+    onError
+  } = config;
+  const steps = ref([]);
+  const isRunning = ref(false);
+  const currentOutput = ref("");
+  const toolCallCount = 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
+  };
+}
+export function createPlanExecuteAgent(config) {
+  const { tools = [] } = config;
+  const plans = ref([]);
+  const currentPlan = ref(null);
+  const results = 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
+  };
+}
+export function createMultiModalMessage(role, contents) {
+  return { role, content: contents };
+}
+export function createImageContent(source, value, mimeType) {
+  return {
+    type: "image",
+    ...source === "url" ? { url: value } : { base64: value },
+    mimeType: mimeType || (source === "base64" ? "image/png" : void 0)
+  };
+}
+export function createImageUrlContent(url, detail) {
+  return {
+    type: "image_url",
+    url,
+    mimeType: detail
+  };
+}
+export function createAudioContent(base64, mimeType = "audio/m4a") {
+  return {
+    type: "audio",
+    base64,
+    mimeType
+  };
+}
+export function createVideoContent(base64, mimeType = "video/mp4") {
+  return {
+    type: "video",
+    base64,
+    mimeType
+  };
+}
+export 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 }
+  };
+}
+export function createChainOfThought(config = { mode: "standard" }) {
+  const { mode = "standard", maxDepth = 5, showConfidence = false } = config;
+  const reasoningSteps = 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 }
+  };
+}
+export 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 }
+  };
+}
+export 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 }
+  };
+}
+export function createTracer() {
+  const spans = ref([]);
+  const events = 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
+  };
+}
+export 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
+  };
+}
+export function fromZodSchema(schema2) {
+  return {
+    type: "object",
+    schema: schema2,
+    toJSONSchema: () => schema2
+  };
+}
+export function createJSONSchema(definition) {
+  return definition;
+}
+export const 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
+  })
+};
+export function parseStructuredOutput(output, _schema) {
+  try {
+    const jsonMatch = output.match(/\{[\s\S]*\}/);
+    if (jsonMatch) {
+      return JSON.parse(jsonMatch[0]);
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}