@yh-ui/ai-sdk 0.1.21

package/dist/agent-enhanced.d.ts

@@ -0,0 +1,143 @@
+/**
+ * YH-UI AI SDK - 增强版 Agent
+ *
+ * 支持多种推理模式：
+ * - Reflexion: 自我反思，从错误中学习
+ * - ReWOO: 分离推理与工具调用
+ * - LCEL 风格链式编排
+ */
+import { type Ref } from 'vue';
+import type { AgentStep, AgentTool, AgentResult, StopCondition } from './future';
+/** Agent 推理模式 */
+export type ReasoningMode = 'react' | 'reflexion' | 'rewoo' | 'plan-execute';
+/** 增强版 Agent 配置 */
+export interface EnhancedAgentConfig {
+    /** 推理模式 */
+    mode: ReasoningMode;
+    /** 最大迭代次数 */
+    maxIterations?: number;
+    /** 最大工具调用次数 */
+    maxToolCalls?: number;
+    /** 是否返回推理过程 */
+    returnReasoning?: boolean;
+    /** 工具列表 */
+    tools?: AgentTool[];
+    /** 停止条件 */
+    stopConditions?: StopCondition[];
+    /** 反思次数（Reflexion 专用） */
+    maxReflections?: number;
+    /** 错误处理 */
+    onError?: (error: Error, step: AgentStep) => void | Promise<void>;
+}
+/** LCEL 链步骤 */
+export interface ChainStep {
+    name: string;
+    handler: (input: unknown) => unknown | Promise<unknown>;
+    onError?: (error: Error) => void;
+}
+/** LCEL 链 */
+export interface Chain {
+    pipe(step: ChainStep): Chain;
+    invoke(input: unknown): Promise<unknown>;
+}
+/**
+ * 创建 LCEL 风格链
+ *
+ * @example
+ * ```ts
+ * const chain = createChain()
+ *   .pipe({ name: 'parse', handler: async (input) => JSON.parse(input as string) })
+ *   .pipe({ name: 'validate', handler: async (input) => { if (!input) throw new Error('Empty'); return input } })
+ *   .pipe({ name: 'transform', handler: async (input) => ({ data: input }) })
+ *
+ * const result = await chain.invoke('{"a":1}')
+ * ```
+ */
+export declare function createChain(initialHandler?: (input: unknown) => unknown | Promise<unknown>): Chain;
+/**
+ * 创建并行链（类似 LangChain RunnableParallel）
+ */
+export declare function createParallelChain(steps: Record<string, (input: unknown) => unknown | Promise<unknown>>): Chain;
+/**
+ * Reflexion Agent 配置
+ */
+export interface ReflexionConfig extends Omit<EnhancedAgentConfig, 'mode'> {
+    mode: 'reflexion';
+    /** 记忆上下文窗口大小 */
+    memoryWindow?: number;
+}
+/**
+ * 创建 Reflexion Agent
+ * 特点：执行后进行自我反思，从错误中学习并改进下一步
+ */
+export declare function createReflexionAgent(config: ReflexionConfig): {
+    run: (input: string, executeFn: (prompt: string) => Promise<string>, toolFn?: (toolName: string, args: Record<string, unknown>) => Promise<string>) => Promise<AgentResult>;
+    steps: Ref<AgentStep[]>;
+    reflections: Ref<string[]>;
+    isRunning: Ref<boolean, boolean>;
+};
+/**
+ * ReWOO Agent 配置
+ */
+export interface ReWOOConfig extends Omit<EnhancedAgentConfig, 'mode'> {
+    mode: 'rewoo';
+    /** 计划生成器 */
+    planner?: (task: string) => Promise<{
+        steps: Array<{
+            id: string;
+            description: string;
+            dependentIds: string[];
+        }>;
+    }>;
+}
+/**
+ * 创建 ReWOO Agent
+ * 特点：先制定完整计划，再批量执行工具，最后基于所有结果生成答案
+ */
+export declare function createReWOOAgent(config: ReWOOConfig): {
+    run: (input: string, executeFn: (prompt: string) => Promise<string>) => Promise<AgentResult>;
+    steps: Ref<AgentStep[]>;
+    plan: Ref<Array<{
+        id: string;
+        description: string;
+        result?: string;
+    }>>;
+    isRunning: Ref<boolean, boolean>;
+};
+/**
+ * 创建增强版 Agent（工厂函数）
+ *
+ * @example
+ * ```ts
+ * // Reflexion
+ * const agent = createEnhancedAgent({
+ *   mode: 'reflexion',
+ *   maxIterations: 5,
+ *   tools: [...]
+ * })
+ *
+ * // ReWOO
+ * const agent = createEnhancedAgent({
+ *   mode: 'rewoo',
+ *   maxIterations: 10,
+ *   tools: [...]
+ * })
+ *
+ * const result = await agent.run('任务描述', llmCall, toolCall)
+ * ```
+ */
+export declare function createEnhancedAgent(config: EnhancedAgentConfig): {
+    run: (input: string, executeFn: (prompt: string) => Promise<string>, toolFn?: (toolName: string, args: Record<string, unknown>) => Promise<string>) => Promise<AgentResult>;
+    steps: Ref<AgentStep[]>;
+    reflections: Ref<string[]>;
+    isRunning: Ref<boolean, boolean>;
+} | {
+    run: (input: string, executeFn: (prompt: string) => Promise<string>) => Promise<AgentResult>;
+    steps: Ref<AgentStep[]>;
+    plan: Ref<Array<{
+        id: string;
+        description: string;
+        result?: string;
+    }>>;
+    isRunning: Ref<boolean, boolean>;
+};

package/dist/agent-enhanced.mjs

@@ -0,0 +1,267 @@
+import { ref } from "vue";
+export function createChain(initialHandler) {
+  const steps = [];
+  if (initialHandler) {
+    steps.push({ name: "initial", handler: initialHandler });
+  }
+  return {
+    pipe(step) {
+      steps.push(step);
+      return this;
+    },
+    async invoke(input) {
+      let current = input;
+      for (const step of steps) {
+        try {
+          current = await step.handler(current);
+        } catch (err) {
+          if (step.onError) {
+            step.onError(err);
+          } else {
+            throw err;
+          }
+        }
+      }
+      return current;
+    }
+  };
+}
+export function createParallelChain(steps) {
+  return {
+    pipe(step) {
+      steps[step.name] = step.handler;
+      return this;
+    },
+    async invoke(input) {
+      const results = {};
+      const promises = Object.entries(steps).map(async ([key, handler]) => {
+        results[key] = await handler(input);
+      });
+      await Promise.all(promises);
+      return results;
+    }
+  };
+}
+export function createReflexionAgent(config) {
+  const {
+    maxIterations = 5,
+    returnReasoning = true,
+    stopConditions = [],
+    memoryWindow = 3,
+    onError
+  } = config;
+  const steps = ref([]);
+  const reflections = ref([]);
+  const isRunning = ref(false);
+  async function run(input, executeFn, toolFn) {
+    isRunning.value = true;
+    steps.value = [];
+    reflections.value = [];
+    let iteration = 0;
+    let currentInput = input;
+    let bestOutput = "";
+    let bestScore = -Infinity;
+    try {
+      while (iteration < maxIterations) {
+        iteration++;
+        const prompt = buildPrompt(currentInput, reflections.value);
+        const response = await executeFn(prompt);
+        let toolResult = "";
+        const actionMatch = response.match(/Action:\s*(\w+)\s*[\n\r]Action Input:\s*(.+)/);
+        if (actionMatch && toolFn) {
+          const [, toolName, toolInputStr] = actionMatch;
+          try {
+            const toolInput = JSON.parse(toolInputStr);
+            toolResult = await toolFn(toolName, toolInput);
+          } catch {
+            toolResult = `Failed to parse: ${toolInputStr}`;
+          }
+        }
+        steps.value.push({
+          id: `step-${iteration}`,
+          type: "thought",
+          content: response,
+          timestamp: /* @__PURE__ */ new Date()
+        });
+        if (toolResult) {
+          steps.value.push({
+            id: `step-${iteration}-obs`,
+            type: "observation",
+            content: toolResult,
+            timestamp: /* @__PURE__ */ new Date()
+          });
+        }
+        const score = await evaluateOutput(response + toolResult);
+        if (score > bestScore) {
+          bestScore = score;
+          bestOutput = response + (toolResult ? `
+
+Observation: ${toolResult}` : "");
+        }
+        if (iteration < maxIterations) {
+          const reflection = await reflect(currentInput, response, toolResult, score);
+          reflections.value.push(reflection);
+          if (reflections.value.length > memoryWindow) {
+            reflections.value.shift();
+          }
+          currentInput = `${input}
+
+Previous attempts:
+${reflections.value.join("\n---\n")}`;
+        }
+        if (checkStop("", bestOutput)) break;
+      }
+      return {
+        output: bestOutput,
+        reasoning: returnReasoning ? steps.value : void 0,
+        toolCalls: iteration,
+        finished: iteration >= maxIterations
+      };
+    } catch (err) {
+      if (onError) await onError(err, steps.value[steps.value.length - 1]);
+      return {
+        output: bestOutput,
+        reasoning: returnReasoning ? steps.value : void 0,
+        toolCalls: iteration,
+        finished: false,
+        error: err
+      };
+    } finally {
+      isRunning.value = false;
+    }
+  }
+  function buildPrompt(input, reflections2) {
+    let prompt = `Task: ${input}
+`;
+    if (reflections2.length > 0) {
+      prompt += `
+Previous reflections:
+${reflections2.join("\n")}
+`;
+    }
+    prompt += "\nProvide your reasoning and any tool actions (Action: toolName\nAction Input: {...}).";
+    return prompt;
+  }
+  async function reflect(task, response, toolResult, score) {
+    return `Attempt ${steps.value.length}: ${score < 5 ? "Need to try different approach" : "Making progress"}`;
+  }
+  async function evaluateOutput(output) {
+    return output.length > 10 ? 5 + Math.random() * 5 : Math.random() * 5;
+  }
+  function checkStop(iterationOutput, bestOutput) {
+    for (const cond of stopConditions) {
+      if (cond.type === "contains" && cond.value) {
+        if (bestOutput.includes(cond.value)) return true;
+      }
+      if (cond.type === "custom" && cond.value) {
+        if (cond.value(bestOutput)) return true;
+      }
+    }
+    return false;
+  }
+  return {
+    run,
+    steps,
+    reflections,
+    isRunning
+  };
+}
+export function createReWOOAgent(config) {
+  const { returnReasoning = true, onError } = config;
+  const steps = ref([]);
+  const plan = ref([]);
+  const isRunning = ref(false);
+  const defaultPlanner = async (task) => {
+    return {
+      steps: [
+        { id: "1", description: `Analyze: ${task.slice(0, 50)}`, dependentIds: [] },
+        { id: "2", description: `Gather info for: ${task.slice(0, 50)}`, dependentIds: ["1"] },
+        { id: "3", description: `Answer: ${task.slice(0, 50)}`, dependentIds: ["1", "2"] }
+      ]
+    };
+  };
+  async function run(input, executeFn) {
+    isRunning.value = true;
+    steps.value = [];
+    plan.value = [];
+    try {
+      const planner = config.planner || defaultPlanner;
+      const planResult = await planner(input);
+      plan.value = planResult.steps;
+      steps.value.push({
+        id: "plan-thought",
+        type: "thought",
+        content: `Generated plan with ${planResult.steps.length} steps`,
+        timestamp: /* @__PURE__ */ new Date()
+      });
+      const results = {};
+      const executed = /* @__PURE__ */ new Set();
+      while (executed.size < plan.value.length) {
+        const readyStep = plan.value.find(
+          (s) => !executed.has(s.id) && s.dependentIds.every((depId) => executed.has(depId))
+        );
+        if (!readyStep) break;
+        const context = Object.entries(results).filter(([id]) => readyStep.dependentIds.includes(id)).map(([, res]) => res).join("\n\n");
+        const stepPrompt = `Step: ${readyStep.description}
+Context: ${context || "No prior context"}
+Execute this step and provide the result.`;
+        const stepResult = await executeFn(stepPrompt);
+        results[readyStep.id] = stepResult;
+        executed.add(readyStep.id);
+        steps.value.push({
+          id: `step-${readyStep.id}`,
+          type: "action",
+          content: readyStep.description,
+          toolOutput: stepResult,
+          timestamp: /* @__PURE__ */ new Date()
+        });
+      }
+      const finalPrompt = `Original Task: ${input}
+
+Execution Results:
+${Object.entries(results).map(([id, res]) => `Step ${id}: ${res}`).join("\n\n")}
+
+Based on the above results, provide the final answer to the original task.`;
+      const finalAnswer = await executeFn(finalPrompt);
+      return {
+        output: finalAnswer,
+        reasoning: returnReasoning ? steps.value : void 0,
+        toolCalls: executed.size,
+        finished: true
+      };
+    } catch (err) {
+      if (onError) {
+        const lastStep = steps.value[steps.value.length - 1];
+        if (lastStep) await onError(err, lastStep);
+      }
+      return {
+        output: "",
+        reasoning: returnReasoning ? steps.value : void 0,
+        toolCalls: 0,
+        finished: false,
+        error: err
+      };
+    } finally {
+      isRunning.value = false;
+    }
+  }
+  return {
+    run,
+    steps,
+    plan,
+    isRunning
+  };
+}
+export function createEnhancedAgent(config) {
+  switch (config.mode) {
+    case "reflexion":
+      return createReflexionAgent(config);
+    case "rewoo":
+      return createReWOOAgent(config);
+    case "react":
+    case "plan-execute":
+      return createReWOOAgent({ ...config, mode: "rewoo" });
+    default:
+      throw new Error(`Unsupported mode: ${config.mode}`);
+  }
+}

package/dist/cache-adapter.cjs

@@ -0,0 +1,99 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createLocalStorageCache = createLocalStorageCache;
+exports.createMemoryCache = createMemoryCache;
+exports.createSessionStorageCache = createSessionStorageCache;
+function createMemoryCache() {
+  const store = /* @__PURE__ */new Map();
+  return {
+    get(key) {
+      const entry = store.get(key);
+      if (!entry) return null;
+      if (entry.expiry > 0 && entry.expiry < Date.now()) {
+        store.delete(key);
+        return null;
+      }
+      return entry.data;
+    },
+    set(key, value, ttlMs = 0) {
+      store.set(key, {
+        data: value,
+        expiry: ttlMs > 0 ? Date.now() + ttlMs : 0
+      });
+    },
+    delete(key) {
+      store.delete(key);
+    },
+    has(key) {
+      const v = this.get(key);
+      return v !== null;
+    }
+  };
+}
+function createLocalStorageCache(prefix = "yh-ai-cache-") {
+  return {
+    get(key) {
+      try {
+        const raw = localStorage.getItem(prefix + key);
+        if (!raw) return null;
+        const item = JSON.parse(raw);
+        if (item.expiry != null && item.expiry < Date.now()) {
+          localStorage.removeItem(prefix + key);
+          return null;
+        }
+        return item.data;
+      } catch {
+        return null;
+      }
+    },
+    set(key, value, ttlMs) {
+      try {
+        const item = {
+          data: value,
+          expiry: ttlMs != null ? Date.now() + ttlMs : void 0
+        };
+        localStorage.setItem(prefix + key, JSON.stringify(item));
+      } catch {}
+    },
+    delete(key) {
+      try {
+        localStorage.removeItem(prefix + key);
+      } catch {}
+    }
+  };
+}
+function createSessionStorageCache(prefix = "yh-ai-cache-") {
+  return {
+    get(key) {
+      try {
+        const raw = sessionStorage.getItem(prefix + key);
+        if (!raw) return null;
+        const item = JSON.parse(raw);
+        if (item.expiry != null && item.expiry < Date.now()) {
+          sessionStorage.removeItem(prefix + key);
+          return null;
+        }
+        return item.data;
+      } catch {
+        return null;
+      }
+    },
+    set(key, value, ttlMs) {
+      try {
+        const item = {
+          data: value,
+          expiry: ttlMs != null ? Date.now() + ttlMs : void 0
+        };
+        sessionStorage.setItem(prefix + key, JSON.stringify(item));
+      } catch {}
+    },
+    delete(key) {
+      try {
+        sessionStorage.removeItem(prefix + key);
+      } catch {}
+    }
+  };
+}

package/dist/cache-adapter.d.ts

@@ -0,0 +1,42 @@
+/**
+ * YH-UI AI SDK - 缓存适配器
+ *
+ * 支持 memory / localStorage / sessionStorage，并可接入 Redis 等持久化后端。
+ */
+export interface CacheAdapter {
+    get(key: string): Promise<unknown> | unknown;
+    set(key: string, value: unknown, ttlMs?: number): Promise<void> | void;
+    delete(key: string): Promise<void> | void;
+    has?(key: string): Promise<boolean> | boolean;
+}
+/**
+ * 内存缓存（内置，与现有 cacheStorage 行为一致）
+ */
+export declare function createMemoryCache(): CacheAdapter;
+/**
+ * localStorage 适配器（TTL 需自行轮询或忽略）
+ */
+export declare function createLocalStorageCache(prefix?: string): CacheAdapter;
+/**
+ * sessionStorage 适配器
+ */
+export declare function createSessionStorageCache(prefix?: string): CacheAdapter;
+/**
+ * Redis 缓存适配器接口（由用户或可选包实现）
+ * 安装 ioredis 后可实现：get/set(key, JSON.stringify(value), 'PX', ttlMs)/del
+ */
+export type RedisCacheConfig = {
+    /** Redis URL 或 { host, port, password } */
+    url?: string;
+    host?: string;
+    port?: number;
+    password?: string;
+    db?: number;
+    keyPrefix?: string;
+    defaultTtlMs?: number;
+};
+/**
+ * 创建 Redis 适配器的类型（实际实现需用户提供或通过可选依赖）
+ * 用法：strategy: 'redis', adapter: createRedisCache({ url: 'redis://...' })
+ */
+export type RedisCacheAdapterFactory = (config: RedisCacheConfig) => CacheAdapter;

package/dist/cache-adapter.mjs

@@ -0,0 +1,95 @@
+export function createMemoryCache() {
+  const store = /* @__PURE__ */ new Map();
+  return {
+    get(key) {
+      const entry = store.get(key);
+      if (!entry) return null;
+      if (entry.expiry > 0 && entry.expiry < Date.now()) {
+        store.delete(key);
+        return null;
+      }
+      return entry.data;
+    },
+    set(key, value, ttlMs = 0) {
+      store.set(key, {
+        data: value,
+        expiry: ttlMs > 0 ? Date.now() + ttlMs : 0
+      });
+    },
+    delete(key) {
+      store.delete(key);
+    },
+    has(key) {
+      const v = this.get(key);
+      return v !== null;
+    }
+  };
+}
+export function createLocalStorageCache(prefix = "yh-ai-cache-") {
+  return {
+    get(key) {
+      try {
+        const raw = localStorage.getItem(prefix + key);
+        if (!raw) return null;
+        const item = JSON.parse(raw);
+        if (item.expiry != null && item.expiry < Date.now()) {
+          localStorage.removeItem(prefix + key);
+          return null;
+        }
+        return item.data;
+      } catch {
+        return null;
+      }
+    },
+    set(key, value, ttlMs) {
+      try {
+        const item = {
+          data: value,
+          expiry: ttlMs != null ? Date.now() + ttlMs : void 0
+        };
+        localStorage.setItem(prefix + key, JSON.stringify(item));
+      } catch {
+      }
+    },
+    delete(key) {
+      try {
+        localStorage.removeItem(prefix + key);
+      } catch {
+      }
+    }
+  };
+}
+export function createSessionStorageCache(prefix = "yh-ai-cache-") {
+  return {
+    get(key) {
+      try {
+        const raw = sessionStorage.getItem(prefix + key);
+        if (!raw) return null;
+        const item = JSON.parse(raw);
+        if (item.expiry != null && item.expiry < Date.now()) {
+          sessionStorage.removeItem(prefix + key);
+          return null;
+        }
+        return item.data;
+      } catch {
+        return null;
+      }
+    },
+    set(key, value, ttlMs) {
+      try {
+        const item = {
+          data: value,
+          expiry: ttlMs != null ? Date.now() + ttlMs : void 0
+        };
+        sessionStorage.setItem(prefix + key, JSON.stringify(item));
+      } catch {
+      }
+    },
+    delete(key) {
+      try {
+        sessionStorage.removeItem(prefix + key);
+      } catch {
+      }
+    }
+  };
+}