@cognipeer/agent-sdk 0.1.1 → 0.2.0

package/dist/index.js

@@ -1,1212 +0,0 @@
-// src/model.ts
-function isSmartModel(m) {
-  return !!m && typeof m === "object" && typeof m.invoke === "function";
-}
-function withTools(model, tools) {
-  if (model?.bindTools) return model.bindTools(tools);
-  return model;
-}
-function fromLangchainModel(lcModel) {
-  if (!lcModel) throw new Error("fromLangchainModel: model is undefined/null");
-  const adapted = {
-    invoke: async (messages) => {
-      const normalizeContent = (content) => {
-        if (content == null) return content;
-        if (typeof content === "string") return content;
-        if (Array.isArray(content)) {
-          return content.map((part) => {
-            if (!part || typeof part !== "object") return part;
-            if (part.type === "text") return { type: "text", text: String(part.text ?? "") };
-            if (part.type === "image_url") {
-              const img = part.image_url;
-              if (typeof img === "string") return { type: "image_url", image_url: { url: img } };
-              if (img && typeof img === "object") {
-                if ("url" in img) return { type: "image_url", image_url: img };
-                if ("base64" in img) {
-                  const media = img.media_type || "image/jpeg";
-                  const dataUrl = `data:${media};base64,${img.base64}`;
-                  const detail = img.detail;
-                  return { type: "image_url", image_url: { url: dataUrl, detail } };
-                }
-              }
-              return part;
-            }
-            return part;
-          });
-        }
-        return content;
-      };
-      const toLC = (m) => {
-        if (m._getType || m.lc_serializable) return m;
-        const role = m.role;
-        return { role, content: normalizeContent(m.content), name: m.name, tool_calls: m.tool_calls, tool_call_id: m.tool_call_id };
-      };
-      const lcMessages = messages.map(toLC);
-      const response = await lcModel.invoke(lcMessages);
-      if (response && typeof response === "object") {
-        const content = response.content ?? response.text ?? "";
-        return {
-          role: response.role || "assistant",
-          content,
-          tool_calls: response.tool_calls,
-          usage: response.usage,
-          response_metadata: response.response_metadata,
-          ...response
-        };
-      }
-      return { role: "assistant", content: String(response ?? "") };
-    },
-    bindTools: (tools) => {
-      if (typeof lcModel.bindTools === "function") {
-        const bound = lcModel.bindTools(tools);
-        return fromLangchainModel(bound);
-      }
-      return adapted;
-    },
-    modelName: lcModel.modelName || lcModel._modelId || lcModel._llmType || lcModel.name,
-    _lc: lcModel
-  };
-  return adapted;
-}
-
-// src/tool.ts
-import { tool } from "@langchain/core/tools";
-function createSmartTool({
-  name,
-  description,
-  schema,
-  func
-}) {
-  return tool(async (input) => {
-    return func(input);
-  }, {
-    name,
-    description,
-    schema
-  });
-}
-function createTool({
-  name,
-  description,
-  schema,
-  func
-}) {
-  return createSmartTool({ name, description, schema, func });
-}
-
-// src/prompts.ts
-function buildSystemPrompt(extra, planning, name = "Agent") {
-  const extraTrimmed = extra?.trim();
-  const agentHeader = `Agent Name: ${name}`;
-  const planningBlock = planning ? `<planning>
-PLANNING IS MANDATORY.
-
-Rules:
-1) Your FIRST action in every task is a single call to the tool "manage_todo_list" with operation="write" and a full, ordered plan (1+ items). Even for trivial tasks, write a one-item plan.
-2) After every non-planning tool call, you MUST immediately call "manage_todo_list" with operation="write" (or re-write) to update statuses and append one-line evidence on the affected item only.
-3) Keep exactly ONE item "in-progress" at any time; all others are "not-started" or "completed".
-4) Never reveal the plan text. Never summarize the plan in the assistant messages.
-5) If you ever produce an assistant message without having written a plan in this session, STOP and first write the plan via "manage_todo_list".
-</planning>` : "";
-  return [
-    agentHeader,
-    "You are an advanced AI agent that is concise, accurate, and helpful.",
-    "Follow these rules:",
-    "- Use tools only when they add value; avoid redundant calls.",
-    "- Never fabricate tool results; if unavailable, say so briefly.",
-    "- Prefer short, structured answers; use bullet points when helpful.",
-    "- Keep privacy and safety: do not reveal secrets or sensitive data.",
-    "- If inputs are ambiguous or missing, ask one concise clarifying question.",
-    "- Reuse prior tool results already present in the conversation when sufficient.",
-    planningBlock,
-    extraTrimmed ? `Extra instructions: ${extraTrimmed}` : ""
-  ].filter(Boolean).join("\n");
-}
-
-// src/agent.ts
-import { z } from "zod";
-
-// src/nodes/resolver.ts
-function createResolverNode() {
-  return async (state) => {
-    const messages = Array.isArray(state.messages) ? state.messages : [];
-    return {
-      ...state,
-      messages,
-      summaries: state.summaries || [],
-      toolCallCount: state.toolCallCount || 0,
-      toolCache: state.toolCache || {},
-      toolHistory: state.toolHistory || [],
-      toolHistoryArchived: state.toolHistoryArchived || [],
-      plan: state.plan || null,
-      planVersion: state.planVersion || 0
-    };
-  };
-}
-
-// src/utils/usage.ts
-function normalizeUsage(raw) {
-  if (!raw) return void 0;
-  const prompt = num(raw.prompt_tokens, raw.input_tokens, raw.promptTokens, raw.total_prompt_tokens);
-  const completion = num(raw.completion_tokens, raw.output_tokens, raw.completionTokens, raw.total_completion_tokens);
-  const total = num(
-    raw.total_tokens,
-    raw.totalTokens,
-    (typeof prompt === "number" ? prompt : 0) + (typeof completion === "number" ? completion : 0)
-  );
-  const promptDetailsSrc = raw.prompt_tokens_details || raw.promptTokensDetails || {};
-  const completionDetailsSrc = raw.completion_tokens_details || raw.completionTokensDetails || {};
-  const normalized = {
-    prompt_tokens: safe(prompt),
-    completion_tokens: safe(completion),
-    total_tokens: safe(total || (prompt || 0) + (completion || 0)),
-    prompt_tokens_details: {
-      cached_tokens: safe(
-        promptDetailsSrc.cached_tokens || promptDetailsSrc.cached || raw.cached_input_tokens || raw.cached_prompt_tokens
-      ),
-      audio_tokens: safe(promptDetailsSrc.audio_tokens)
-    },
-    completion_tokens_details: {
-      reasoning_tokens: safe(completionDetailsSrc.reasoning_tokens),
-      audio_tokens: safe(completionDetailsSrc.audio_tokens),
-      accepted_prediction_tokens: safe(completionDetailsSrc.accepted_prediction_tokens),
-      rejected_prediction_tokens: safe(completionDetailsSrc.rejected_prediction_tokens)
-    },
-    raw
-  };
-  return normalized;
-}
-function num(...vals) {
-  for (const v of vals) {
-    if (v === 0) return 0;
-    if (v == null) continue;
-    const n = Number(v);
-    if (!Number.isNaN(n)) return n;
-  }
-  return void 0;
-}
-function safe(v) {
-  const n = Number(v);
-  return Number.isFinite(n) && n >= 0 ? n : 0;
-}
-
-// src/utils/debugLogger.ts
-import fs from "fs";
-import path from "path";
-function ensureDir(p) {
-  if (!fs.existsSync(p)) fs.mkdirSync(p, { recursive: true });
-}
-function resolveLogsBaseDir(customPath) {
-  const root = process.cwd();
-  const base = customPath && customPath.trim().length > 0 ? customPath : path.join(root, "logs");
-  ensureDir(base);
-  return base;
-}
-function createDebugSession(opts) {
-  const dbg = opts.debug;
-  if (!dbg?.enabled) return void 0;
-  const baseDir = resolveLogsBaseDir(dbg.path);
-  const sessionId = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  const sessionDir = path.join(baseDir, sessionId);
-  if (!dbg.callback) ensureDir(sessionDir);
-  return { sessionId, baseDir, sessionDir, stepIndex: 0, callback: dbg.callback };
-}
-function bumpStep(session) {
-  session.stepIndex += 1;
-  return session.stepIndex - 1;
-}
-function getModelName(model) {
-  return model?.model ?? model?.modelName ?? model?.options?.model ?? model?.lc_alias ?? model?.constructor?.name ?? void 0;
-}
-function serializeAgentTools(tools) {
-  return (tools || []).map((t) => {
-    const name = t.name ?? t.lc_alias ?? t.constructor?.name ?? "tool";
-    const description = t.description ?? t.lc_description ?? void 0;
-    const params = t.schema ?? t.lc_kwargs?.schema ?? t.argsSchema ?? void 0;
-    return {
-      function: {
-        name,
-        description,
-        parameters: params
-      },
-      type: "function"
-    };
-  });
-}
-function formatTools(tools) {
-  try {
-    return JSON.stringify(
-      tools.map((t) => ({
-        function: t?.function ? {
-          name: t.function.name,
-          description: t.function.description,
-          parameters: t.function.parameters
-        } : void 0,
-        type: t?.type
-      })),
-      null,
-      4
-    );
-  } catch {
-    return "[]";
-  }
-}
-function formatMessages(messages) {
-  const lines = [];
-  const push = (s = "") => lines.push(s);
-  for (const m of messages) {
-    const anyM = m;
-    const role = anyM.role || (typeof anyM.getType === "function" ? anyM.getType() : void 0);
-    if (role === "system") {
-      push("### System\n");
-      push(String(anyM.content));
-      push("");
-    } else if (role === "user" || role === "human") {
-      push("### User\n");
-      push(typeof anyM.content === "string" ? anyM.content : JSON.stringify(anyM.content, null, 2));
-      push("");
-    } else if (role === "assistant" || role === "ai") {
-      push("### AI\n");
-      const toolCalls = Array.isArray(anyM.tool_calls) ? anyM.tool_calls : [];
-      if (toolCalls.length) {
-        push("Tool Calls:");
-        for (const tc of toolCalls) {
-          push("```");
-          push(JSON.stringify(tc, null, 2));
-          push("```");
-        }
-      }
-      push(typeof anyM.content === "string" ? anyM.content : JSON.stringify(anyM.content, null, 2));
-      push("");
-    } else if (role === "tool") {
-      push("### ToolResponse\n");
-      const hdr = { name: anyM.name, tool_call_id: anyM.tool_call_id, executionId: anyM.executionId };
-      push("```");
-      push(JSON.stringify(hdr, null, 2));
-      push("```");
-      push(typeof anyM.content === "string" ? anyM.content : JSON.stringify(anyM.content, null, 2));
-      push("");
-    }
-  }
-  return lines.join("\n");
-}
-function formatMarkdown(params) {
-  const { modelName, date, limits, usage, tools = [], messages } = params;
-  const sections = [];
-  const add = (s = "") => sections.push(s);
-  add(`# modelName`);
-  add(String(modelName ?? "unknown"));
-  add("");
-  add(`# date`);
-  add(date);
-  add("");
-  add(`# limitler`);
-  add("```");
-  add(JSON.stringify(limits ?? {}, null, 2));
-  add("```");
-  add("");
-  add(`# usage`);
-  if (usage) {
-    add("```");
-    add(JSON.stringify(usage));
-    add("```");
-  } else {
-    add("(none)");
-  }
-  add("");
-  add(`# tools`);
-  add("```");
-  add(formatTools(tools));
-  add("```");
-  add("");
-  add(`# Messages`);
-  add(formatMessages(messages));
-  return sections.join("\n");
-}
-async function writeStepMarkdown(session, fileName, markdown, payload) {
-  if (session.callback) {
-    session.callback({
-      sessionId: session.sessionId,
-      stepIndex: session.stepIndex,
-      fileName,
-      markdown,
-      messages: payload?.messages ?? [],
-      usage: payload?.usage,
-      modelName: payload?.modelName,
-      limits: payload?.limits,
-      tools: payload?.tools
-    });
-    return;
-  }
-  const fp = path.join(session.sessionDir, fileName);
-  await fs.promises.writeFile(fp, markdown, "utf8");
-}
-
-// src/nodes/agentCore.ts
-function createAgentCoreNode(opts) {
-  return async (state) => {
-    const runtime = state.agent || {
-      name: opts.name,
-      model: opts.model,
-      tools: opts.tools || [],
-      systemPrompt: void 0,
-      limits: opts.limits,
-      useTodoList: void 0,
-      outputSchema: opts.outputSchema
-    };
-    const tools = runtime.tools ?? [];
-    const modelWithTools = runtime.model?.bindTools ? runtime.model.bindTools(tools) : runtime.model;
-    const response = await modelWithTools.invoke([...state.messages]);
-    const messagesWithResponse = [
-      ...state.messages,
-      response
-    ];
-    const rawUsage = response?.usage || response?.response_metadata?.token_usage || response?.response_metadata?.usage;
-    const normalized = normalizeUsage(rawUsage);
-    const modelName = getModelName(runtime.model || opts.model) || "unknown_model";
-    if (normalized) {
-      const usageState = state.usage || { perRequest: [], totals: {} };
-      const id = `${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
-      const turn = usageState.perRequest.length + 1;
-      const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-      const cachedInputTok = normalized.prompt_tokens_details?.cached_tokens;
-      usageState.perRequest.push({ id, modelName, usage: normalized, timestamp, turn, cachedInput: cachedInputTok });
-      const inputTok = normalized.prompt_tokens;
-      const outputTok = normalized.completion_tokens;
-      const totalTok = normalized.total_tokens;
-      const key = modelName;
-      const agg = usageState.totals[key] || { input: 0, output: 0, total: 0, cachedInput: 0 };
-      usageState.totals[key] = {
-        input: agg.input + (Number(inputTok) || 0),
-        output: agg.output + (Number(outputTok) || 0),
-        total: agg.total + (Number(totalTok) || 0),
-        cachedInput: agg.cachedInput + (Number(cachedInputTok) || 0)
-      };
-      state.usage = usageState;
-    }
-    return { messages: messagesWithResponse, usage: state.usage };
-  };
-}
-
-// src/nodes/tools.ts
-import { nanoid } from "nanoid";
-import { ToolMessage } from "@langchain/core/messages";
-function createToolsNode(initialTools, opts) {
-  const baseToolByName = /* @__PURE__ */ new Map();
-  for (const t of initialTools) baseToolByName.set(t.name, t);
-  return async (state) => {
-    const runtime = state.agent || {
-      name: opts?.name,
-      model: opts?.model,
-      tools: initialTools,
-      limits: opts?.limits,
-      systemPrompt: opts?.systemPrompt,
-      useTodoList: opts?.useTodoList,
-      outputSchema: opts?.outputSchema
-    };
-    const activeTools = runtime.tools;
-    const toolByName = /* @__PURE__ */ new Map();
-    for (const t of activeTools) toolByName.set(t.name, t);
-    const limits = {
-      maxToolCalls: runtime.limits?.maxToolCalls ?? 10,
-      maxParallelTools: Math.max(1, runtime.limits?.maxParallelTools ?? 1)
-    };
-    const appended = [];
-    const onEvent = state.ctx?.__onEvent;
-    for (const t of toolByName.values()) {
-      const anyT = t;
-      if (anyT._stateRef && typeof anyT._stateRef === "object") {
-        anyT._stateRef.toolHistory = state.toolHistory;
-        anyT._stateRef.toolHistoryArchived = state.toolHistoryArchived;
-        anyT._stateRef.__onEvent = onEvent;
-      }
-    }
-    const last = state.messages[state.messages.length - 1];
-    let toolCount = state.toolCallCount || 0;
-    const toolCalls = Array.isArray(
-      last?.tool_calls
-    ) ? last.tool_calls : [];
-    const toolHistory = state.toolHistory || [];
-    const remaining = Math.max(0, limits.maxToolCalls - toolCount);
-    const planned = toolCalls.slice(0, remaining);
-    const skipped = toolCalls.slice(remaining);
-    for (const tc of skipped) {
-      onEvent?.({ type: "tool_call", phase: "skipped", name: tc.name, id: tc.id, args: tc.args });
-      appended.push(new ToolMessage({
-        content: `Skipped tool due to tool-call limit: ${tc.name}`,
-        tool_call_id: tc.id || `${tc.name}_${appended.length}`,
-        name: tc.name
-      }));
-    }
-    const runOne = async (tc) => {
-      const t = toolByName.get(tc.name);
-      if (!t) {
-        onEvent?.({ type: "tool_call", phase: "error", name: tc.name, id: tc.id, args: tc.args, error: { message: "Tool not found" } });
-        appended.push(
-          new ToolMessage({
-            content: `Tool not found: ${tc.name}`,
-            tool_call_id: tc.id || `${tc.name}_${appended.length}`,
-            name: tc.name
-          })
-        );
-        toolCount += 1;
-        return;
-      }
-      let args = tc.args;
-      if (typeof args === "string") {
-        try {
-          args = JSON.parse(args);
-        } catch (_) {
-        }
-      }
-      try {
-        const start = Date.now();
-        onEvent?.({ type: "tool_call", phase: "start", name: t.name, id: tc.id, args });
-        let output;
-        const anyTool = t;
-        if (typeof anyTool.func === "function") output = await anyTool.func(args);
-        else if (typeof anyTool.invoke === "function") output = await anyTool.invoke(args);
-        else if (typeof anyTool.call === "function") output = await anyTool.call(args);
-        else if (typeof anyTool._call === "function") output = await anyTool._call(args);
-        else if (typeof anyTool.run === "function") output = await anyTool.run(args);
-        else throw new Error("Tool is not invokable");
-        if (output && typeof output === "object" && output.__handoff && output.__handoff.runtime) {
-          const newRuntime = output.__handoff.runtime;
-          const executionId2 = nanoid();
-          toolHistory.push({ executionId: executionId2, toolName: t.name, args, output: "handoff:ok", rawOutput: output, timestamp: (/* @__PURE__ */ new Date()).toISOString(), tool_call_id: tc.id });
-          appended.push(new ToolMessage({ content: "ok", tool_call_id: tc.id || `${tc.name}_${appended.length}`, name: tc.name }));
-          onEvent?.({ type: "handoff", from: runtime.name, to: newRuntime.name, toolName: t.name });
-          state.agent = newRuntime;
-          onEvent?.({ type: "tool_call", phase: "success", name: t.name, id: tc.id, args, result: "handoff", durationMs: Date.now() - start });
-          toolCount += 1;
-          return;
-        }
-        const content = typeof output === "string" ? output : JSON.stringify(output);
-        if (output && typeof output === "object" && output.__finalStructuredOutput) {
-          if (!state.ctx) state.ctx = {};
-          state.ctx.__structuredOutputParsed = output.data;
-          state.ctx.__finalizedDueToStructuredOutput = true;
-        }
-        const executionId = nanoid();
-        toolHistory.push({ executionId, toolName: t.name, args, output, rawOutput: output, timestamp: (/* @__PURE__ */ new Date()).toISOString(), tool_call_id: tc.id });
-        appended.push(new ToolMessage({ content, tool_call_id: tc.id || `${tc.name}_${appended.length}`, name: tc.name }));
-        onEvent?.({ type: "tool_call", phase: "success", name: t.name, id: tc.id, args, result: output, durationMs: Date.now() - start });
-        toolCount += 1;
-      } catch (e) {
-        const executionId = nanoid();
-        toolHistory.push({ executionId, toolName: t.name, args, output: `Error executing tool: ${e?.message || String(e)}`, rawOutput: null, timestamp: (/* @__PURE__ */ new Date()).toISOString(), tool_call_id: tc.id });
-        appended.push(new ToolMessage({ content: `Error executing tool: ${e?.message || String(e)}`, tool_call_id: tc.id || `${tc.name}_${appended.length}`, name: tc.name }));
-        onEvent?.({ type: "tool_call", phase: "error", name: t.name, id: tc.id, args, error: { message: e?.message || String(e) } });
-        toolCount += 1;
-      }
-    };
-    const concurrency = Math.max(1, limits.maxParallelTools);
-    for (let i = 0; i < planned.length; i += concurrency) {
-      const batch = planned.slice(i, i + concurrency);
-      await Promise.all(batch.map(runOne));
-    }
-    return { messages: [...state.messages, ...appended], toolCallCount: toolCount, toolHistory, agent: state.agent };
-  };
-}
-
-// src/nodes/toolLimitFinalize.ts
-function createToolLimitFinalizeNode(_opts) {
-  return async (state) => {
-    const notice = { role: "system", content: "Tool-call limit reached. Produce the best possible final answer using the available context and prior tool outputs. Do not call any more tools." };
-    const ctx = { ...state.ctx || {}, __finalizedDueToToolLimit: true };
-    return { messages: [...state.messages, notice], ctx };
-  };
-}
-
-// src/agent.ts
-function createAgent(opts) {
-  const resolver = createResolverNode();
-  const agentCore = createAgentCoreNode(opts);
-  const toolsBase = [...opts.tools ?? []];
-  if (opts.outputSchema) {
-    const responseTool = createSmartTool({
-      name: "response",
-      description: "Finalize the answer by returning the final structured JSON matching the required schema. Call exactly once when you are fully done, then stop.",
-      schema: opts.outputSchema,
-      func: async (data) => ({ __finalStructuredOutput: true, data })
-    });
-    toolsBase.push(responseTool);
-  }
-  const toolsNode = createToolsNode(toolsBase, opts);
-  const finalizeNode = createToolLimitFinalizeNode(opts);
-  async function runLoop(initial, config) {
-    let state = await resolver(initial);
-    const maxToolCalls = opts.limits?.maxToolCalls ?? 10;
-    const iterationLimit = Math.max(maxToolCalls * 3 + 10, 40);
-    let iterations = 0;
-    while (iterations < iterationLimit) {
-      iterations++;
-      state = { ...state, ...await agentCore(state) };
-      const lastMsg = state.messages[state.messages.length - 1];
-      const toolCalls = Array.isArray(lastMsg?.tool_calls) ? lastMsg.tool_calls : [];
-      const toolCallCount = state.toolCallCount || 0;
-      if (state.ctx?.__finalizedDueToToolLimit) {
-        break;
-      }
-      if (toolCallCount >= maxToolCalls && toolCalls.length > 0) {
-        state = { ...state, ...await finalizeNode(state) };
-        continue;
-      }
-      if (toolCalls.length === 0) break;
-      state = { ...state, ...await toolsNode(state) };
-      if (state.ctx?.__finalizedDueToStructuredOutput) break;
-    }
-    return state;
-  }
-  const runtime = {
-    name: opts.name,
-    model: opts.model,
-    tools: toolsBase,
-    systemPrompt: void 0,
-    limits: opts.limits,
-    useTodoList: void 0,
-    outputSchema: opts.outputSchema
-  };
-  const instance = {
-    invoke: async (input, config) => {
-      const onEvent = config?.onEvent;
-      const emit = (e) => {
-        try {
-          onEvent?.(e);
-        } catch {
-        }
-      };
-      const initial = {
-        messages: input.messages || [],
-        summaries: input.summaries || [],
-        toolCallCount: input.toolCallCount || 0,
-        toolCache: input.toolCache || {},
-        toolHistory: input.toolHistory || [],
-        toolHistoryArchived: input.toolHistoryArchived || [],
-        metadata: input.metadata,
-        ctx: { ...input.ctx || {}, __onEvent: onEvent },
-        plan: input.plan || null,
-        planVersion: input.planVersion || 0,
-        agent: input.agent || runtime,
-        usage: input.usage || { perRequest: [], totals: {} }
-      };
-      const res = await runLoop(initial, config);
-      const finalMsg = res.messages[res.messages.length - 1];
-      let content = "";
-      if (typeof finalMsg?.content === "string") content = finalMsg.content;
-      else if (Array.isArray(finalMsg?.content)) content = finalMsg.content.map((c) => typeof c === "string" ? c : c?.text ?? c?.content ?? "").join("");
-      let parsed = void 0;
-      const schema = opts.outputSchema;
-      if (schema && res.ctx?.__structuredOutputParsed) {
-        parsed = res.ctx.__structuredOutputParsed;
-      } else if (schema && content) {
-        let jsonText = null;
-        const fenced = content.match(/```(?:json)?\n([\s\S]*?)```/i);
-        if (fenced && fenced[1]) jsonText = fenced[1].trim();
-        else {
-          const braceIdx = content.indexOf("{");
-          const bracketIdx = content.indexOf("[");
-          const start = [braceIdx, bracketIdx].filter((i) => i >= 0).sort((a, b) => a - b)[0];
-          if (start !== void 0) jsonText = content.slice(start).trim();
-        }
-        try {
-          const raw = JSON.parse(jsonText ?? content);
-          parsed = schema.parse(raw);
-        } catch {
-        }
-      }
-      emit({ type: "finalAnswer", content: typeof finalMsg?.content === "string" ? finalMsg.content : content });
-      return {
-        content,
-        output: parsed,
-        metadata: { usage: res.usage },
-        messages: res.messages,
-        state: res
-      };
-    },
-    asTool: ({ toolName, description, inputDescription }) => {
-      const schema = z.object({ input: z.string().describe(inputDescription || "Input for delegated agent") });
-      return createSmartTool({
-        name: toolName,
-        description: description || `Delegate task to agent ${opts.name || "Agent"}`,
-        schema,
-        func: async ({ input }) => {
-          const res = await instance.invoke({ messages: [{ role: "user", content: input }] });
-          return { content: res.content };
-        }
-      });
-    },
-    asHandoff: ({ toolName, description, schema }) => {
-      const finalName = toolName || `handoff_to_${runtime.name || "agent"}`;
-      const zschema = schema || z.object({ reason: z.string().describe("Reason for handoff") });
-      const tool3 = createSmartTool({
-        name: finalName,
-        description: description || `Handoff control to agent ${runtime.name || "Agent"}`,
-        schema: zschema,
-        func: async (_args) => ({ __handoff: { runtime } })
-      });
-      return { type: "handoff", toolName: finalName, description: description || "", schema: zschema, target: instance };
-    },
-    __runtime: runtime
-  };
-  if (opts.handoffs && Array.isArray(opts.handoffs)) {
-    const handoffTools = opts.handoffs.map((h) => {
-      const schema = h.schema || z.object({ reason: z.string().describe("Reason for handoff") });
-      return createSmartTool({
-        name: h.toolName,
-        description: h.description || `Handoff to ${h.target.__runtime.name || "agent"}`,
-        schema,
-        func: async (_args) => ({ __handoff: { runtime: h.target.__runtime } })
-      });
-    });
-    runtime.tools = [...runtime.tools, ...handoffTools];
-  }
-  return instance;
-}
-
-// src/nodes/agent.ts
-function createAgentNode(opts) {
-  return async (state) => {
-    const runtime = state.agent || {
-      name: opts.name,
-      model: opts.model,
-      tools: opts.tools || [],
-      systemPrompt: opts.systemPrompt,
-      limits: opts.limits,
-      useTodoList: opts.useTodoList,
-      outputSchema: opts.outputSchema
-    };
-    const tools = runtime.tools ?? [];
-    const limits = {
-      maxToolCalls: runtime.limits?.maxToolCalls ?? 10,
-      toolOutputTokenLimit: runtime.limits?.toolOutputTokenLimit ?? 5e3,
-      contextTokenLimit: runtime.limits?.contextTokenLimit ?? 6e4,
-      summaryTokenLimit: runtime.limits?.summaryTokenLimit ?? 5e4
-    };
-    const modelWithTools = runtime.model?.bindTools ? runtime.model.bindTools(tools) : runtime.model;
-    const structuredOutputHint = runtime.outputSchema ? [
-      "A structured output schema is active.",
-      "Do NOT output the final JSON directly as an assistant message.",
-      "When completely finished, call tool `response` passing the final JSON matching the schema as its arguments (direct object).",
-      "Call it exactly once then STOP producing further assistant messages."
-    ].join("\n") : "";
-    const systemMsg = {
-      role: "system",
-      content: buildSystemPrompt(
-        [runtime.systemPrompt, structuredOutputHint].filter(Boolean).join("\n"),
-        runtime.useTodoList === true,
-        runtime.name || "Agent"
-      )
-    };
-    const messages = [systemMsg, ...state.messages];
-    const debugSession = state.ctx?.__debugSession;
-    const response = await modelWithTools.invoke([systemMsg, ...state.messages]);
-    const messagesWithResponse = [
-      ...messages,
-      response
-    ];
-    const messagesWithSystem = [
-      systemMsg,
-      ...messagesWithResponse
-    ];
-    const rawUsage = response?.usage || response?.response_metadata?.token_usage || response?.response_metadata?.usage;
-    const normalized = normalizeUsage(rawUsage);
-    const modelName = getModelName(runtime.model || opts.model) || "unknown_model";
-    if (normalized) {
-      const usageState = state.usage || { perRequest: [], totals: {} };
-      const id = `${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
-      const turn = usageState.perRequest.length + 1;
-      const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-      const cachedInputTok = normalized.prompt_tokens_details.cached_tokens;
-      usageState.perRequest.push({ id, modelName, usage: normalized, timestamp, turn, cachedInput: cachedInputTok });
-      const inputTok = normalized.prompt_tokens;
-      const outputTok = normalized.completion_tokens;
-      const totalTok = normalized.total_tokens;
-      const key = modelName;
-      const agg = usageState.totals[key] || { input: 0, output: 0, total: 0, cachedInput: 0 };
-      usageState.totals[key] = {
-        input: agg.input + (Number(inputTok) || 0),
-        output: agg.output + (Number(outputTok) || 0),
-        total: agg.total + (Number(totalTok) || 0),
-        cachedInput: agg.cachedInput + (Number(cachedInputTok) || 0)
-      };
-      state.usage = usageState;
-    }
-    if (debugSession) {
-      const idx = bumpStep(debugSession);
-      const fileName = `${String(idx).padStart(2, "0")}.md`;
-      const markdown = formatMarkdown({
-        modelName: getModelName(runtime.model || opts.model),
-        date: (/* @__PURE__ */ new Date()).toISOString(),
-        limits: runtime.limits,
-        // IMPORTANT: log only per-request normalized usage
-        usage: normalized,
-        tools: serializeAgentTools(tools),
-        messages: messagesWithSystem
-      });
-      await writeStepMarkdown(debugSession, fileName, markdown, {
-        messages: messagesWithSystem,
-        usage: normalized,
-        modelName: getModelName(runtime.model || opts.model),
-        limits: runtime.limits,
-        tools: serializeAgentTools(tools)
-      });
-    }
-    return { messages: messagesWithResponse, usage: state.usage };
-  };
-}
-
-// src/nodes/contextSummarize.ts
-import { nanoid as nanoid2 } from "nanoid";
-
-// src/utils/utilTokens.ts
-function countApproxTokens(text) {
-  if (!text) return 0;
-  return Math.ceil(text.length / 4);
-}
-
-// src/nodes/contextSummarize.ts
-var systemMessage = (content) => ({ role: "system", content });
-var humanMessage = (content) => ({ role: "user", content });
-var toolMessage = (name, content, tool_call_id) => ({ role: "tool", name, content, tool_call_id });
-function createContextSummarizeNode(opts) {
-  return async (state) => {
-    const messages = state.messages || [];
-    const summaryTokenLimit = opts.limits?.summaryTokenLimit ?? opts.limits?.summary_token_limit ?? 1e5;
-    const model = opts.model;
-    const archived = state.toolHistoryArchived ? [...state.toolHistoryArchived] : [];
-    const live = state.toolHistory ? [...state.toolHistory] : [];
-    const byCallId = /* @__PURE__ */ new Map();
-    for (const item of archived) {
-      if (item.tool_call_id) byCallId.set(item.tool_call_id, item);
-    }
-    for (const item of live) {
-      if (item.tool_call_id) byCallId.set(item.tool_call_id, item);
-    }
-    for (const item of live) {
-      if (!item.executionId) item.executionId = nanoid2();
-    }
-    const getText = (m) => {
-      if (!m) return "";
-      const c = m.content;
-      if (typeof c === "string") return c;
-      if (Array.isArray(c)) return c.map((p) => typeof p === "string" ? p : p?.text ?? p?.content ?? "").join("");
-      return String(c ?? "");
-    };
-    const sysText = "You are a concise summarization assistant for a tool-using agent. Summarize prior tool executions into a compact brief that preserves key facts, decisions, and outputs. Reference executionId values where helpful. Avoid repeating raw data; prefer synthesis.";
-    const sys = systemMessage(sysText);
-    let summaryText = "";
-    try {
-      const limit = Math.max(1e3, Number(summaryTokenLimit) || 1e5);
-      const safetyBuffer = Math.floor(Math.min(4e3, limit * 0.05));
-      const perCallBudget = Math.max(500, limit - safetyBuffer);
-      const safeToolPair = opts?.safeToolPair !== false;
-      const chunks = [];
-      let current = [];
-      let currentTokens = countApproxTokens(sysText);
-      let pendingToolCalls = /* @__PURE__ */ new Set();
-      const extractToolCallIds = (msg) => {
-        const tc = msg?.additional_kwargs?.tool_calls;
-        if (!Array.isArray(tc) || tc.length === 0) return [];
-        return tc.map((c) => c?.id).filter((id) => typeof id === "string");
-      };
-      for (let i = 0; i < messages.length; i++) {
-        const m = messages[i];
-        const text = getText(m);
-        const tks = countApproxTokens(text);
-        const isAIWithToolCalls = safeToolPair && m?.role === "assistant" && extractToolCallIds(m).length > 0;
-        const isToolMsg = safeToolPair && m?.role === "tool";
-        const toolCallId = isToolMsg ? m.tool_call_id : void 0;
-        const wouldExceed = currentTokens + tks > perCallBudget && current.length > 0;
-        if (wouldExceed) {
-          let forceAddToCurrent = false;
-          if (safeToolPair) {
-            if (isToolMsg && toolCallId && pendingToolCalls.has(toolCallId)) {
-              forceAddToCurrent = true;
-            } else if (isAIWithToolCalls) {
-            } else if (pendingToolCalls.size > 0) {
-            }
-          }
-          if (!forceAddToCurrent) {
-            if (current.length > 0) {
-              chunks.push(current);
-            }
-            current = [];
-            currentTokens = countApproxTokens(sysText);
-            pendingToolCalls = /* @__PURE__ */ new Set();
-          }
-        }
-        current.push(m);
-        currentTokens += tks;
-        if (isAIWithToolCalls) {
-          for (const id of extractToolCallIds(m)) pendingToolCalls.add(id);
-        }
-        if (isToolMsg && toolCallId && pendingToolCalls.has(toolCallId)) {
-          pendingToolCalls.delete(toolCallId);
-        }
-        if (currentTokens >= perCallBudget && pendingToolCalls.size === 0) {
-          chunks.push(current);
-          current = [];
-          currentTokens = countApproxTokens(sysText);
-          pendingToolCalls = /* @__PURE__ */ new Set();
-        }
-      }
-      if (current.length > 0) {
-        chunks.push(current);
-      }
-      const partials = [];
-      for (const chunk of chunks) {
-        let resp = null;
-        try {
-          resp = await (model?.invoke ? model.invoke([sys, ...chunk]) : null);
-          const c = resp?.content;
-          const text = typeof c === "string" ? c : Array.isArray(c) ? c.map((p) => typeof p === "string" ? p : p?.text ?? p?.content ?? "").join("") : "";
-          partials.push((text || "").trim());
-        } catch (e) {
-          console.error("Summarization chunk failed:", e);
-          partials.push("[summary unavailable for one chunk]");
-        }
-      }
-      const mergeSysText = "You merge partial summaries into a single cohesive, non-redundant summary that preserves key facts and decisions. Be concise.";
-      const mergeSys = systemMessage(mergeSysText);
-      const mergeIteratively = async (texts) => {
-        if (texts.length === 0) return "";
-        if (texts.length === 1) return texts[0];
-        const groups = [];
-        let group = [];
-        let toks = countApproxTokens(mergeSysText);
-        for (const t of texts) {
-          const tt = `- ${t}`;
-          const tk = countApproxTokens(tt);
-          if (toks + tk > perCallBudget && group.length > 0) {
-            groups.push(group);
-            group = [];
-            toks = countApproxTokens(mergeSysText);
-          }
-          group.push(tt);
-          toks += tk;
-        }
-        if (group.length > 0) groups.push(group);
-        const next = [];
-        for (const g of groups) {
-          const mergePrompt = humanMessage(`Merge the following partial summaries into a single concise brief. Avoid duplication, keep key facts and decisions.
-
-${g.join("\n")}
-
-Merged summary:`);
-          try {
-            const r = await (model?.invoke ? model.invoke([mergeSys, mergePrompt]) : null);
-            const cc = r?.content;
-            const txt = typeof cc === "string" ? cc : Array.isArray(cc) ? cc.map((p) => typeof p === "string" ? p : p?.text ?? p?.content ?? "").join("") : "";
-            next.push((txt || "").trim());
-          } catch (e) {
-            console.error("Merge summarization failed:", e);
-            next.push(g.join(" "));
-          }
-        }
-        return mergeIteratively(next);
-      };
-      summaryText = await mergeIteratively(partials);
-      if (!summaryText) summaryText = "Context summarized.";
-    } catch (e) {
-      console.error("Error during context summarization:", e);
-      summaryText = "Context summarized.";
-    }
-    const rewritten = [];
-    const alreadySummarized = (content) => {
-      const text = typeof content === "string" ? content : Array.isArray(content) ? content.map((p) => typeof p === "string" ? p : p?.text ?? p?.content ?? "").join("") : String(content ?? "");
-      return /\bSUMMARIZED\b/.test(text);
-    };
-    for (const m of messages) {
-      if (m.getType() === "tool") {
-        const toolMessageObj = m;
-        if (alreadySummarized(toolMessageObj.content) || toolMessageObj.name === "context_summarize" || toolMessageObj.name === "manage_todo_list") {
-          rewritten.push(m);
-          continue;
-        }
-        const callId = toolMessageObj.tool_call_id;
-        const safeId = callId || `summarized_${nanoid2(6)}`;
-        let hist = callId ? byCallId.get(callId) : void 0;
-        if (!hist) {
-          hist = {
-            executionId: nanoid2(),
-            toolName: toolMessageObj.name || "unknown_tool",
-            args: null,
-            output: typeof toolMessageObj.content === "string" ? toolMessageObj.content : Array.isArray(toolMessageObj.content) ? toolMessageObj.content.map((p) => typeof p === "string" ? p : p?.text ?? p?.content ?? "").join("") : String(toolMessageObj.content ?? ""),
-            rawOutput: void 0,
-            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-            summarized: true,
-            messageId: void 0,
-            tool_call_id: callId,
-            fromCache: false
-          };
-          if (callId) byCallId.set(callId, hist);
-          archived.push({ ...hist });
-        }
-        if (!hist.executionId) hist.executionId = nanoid2();
-        hist.summarized = true;
-        rewritten.push({
-          role: "tool",
-          content: `SUMMARIZED executionId:'${hist.executionId}'`,
-          tool_call_id: safeId,
-          name: toolMessage.name
-        });
-        continue;
-      }
-      rewritten.push(m);
-    }
-    const summarizeCallId = `summarize_${nanoid2(6)}`;
-    const summarizeArgs = { reason: "Exceeded token limit: summarize prior tool outputs for context." };
-    const syntheticAssistant = {
-      role: "assistant",
-      content: "",
-      additional_kwargs: {
-        tool_calls: [
-          { id: summarizeCallId, type: "function", function: { name: "context_summarize", arguments: JSON.stringify(summarizeArgs) } }
-        ]
-      }
-    };
-    const summaryExecId = nanoid2();
-    const syntheticToolResp = {
-      role: "tool",
-      content: `${summaryText}`,
-      tool_call_id: summarizeCallId,
-      name: "context_summarize"
-    };
-    for (const item of live) item.summarized = true;
-    const merged = [...archived, ...live];
-    const dedupMap = /* @__PURE__ */ new Map();
-    for (const it of merged) {
-      const key = it.tool_call_id || `${it.toolName}:${it.timestamp}`;
-      dedupMap.set(key, { ...it });
-    }
-    const newArchived = Array.from(dedupMap.values());
-    const onEvent = state.ctx?.__onEvent;
-    onEvent?.({ type: "summarization", summary: summaryText, archivedCount: newArchived.length });
-    return {
-      messages: [...rewritten, syntheticAssistant, syntheticToolResp],
-      toolHistoryArchived: newArchived,
-      toolHistory: [],
-      ctx: { ...state.ctx || {}, __contextSummarized: true }
-    };
-  };
-}
-
-// src/utils/tokenManager.ts
-async function applyTokenLimits({
-  state,
-  model,
-  limits
-}) {
-  const messages = state.messages || [];
-  const budget = limits.contextTokenLimit;
-  let total = messages.reduce((acc, m) => acc + countApproxTokens(String(m.content || "")), 0);
-  if (total <= budget) return state;
-  const newMessages = [...messages];
-  return { ...state, messages: newMessages };
-}
-
-// src/contextTools.ts
-import { tool as tool2 } from "@langchain/core/tools";
-import { z as z2 } from "zod";
-function createContextTools(stateRef, opts) {
-  const tools = [];
-  if (opts?.planningEnabled) {
-    const manageTodo = tool2(
-      async ({ operation, todoList }) => {
-        const onEvent = manageTodo._stateRef?.__onEvent;
-        if (operation === "read") {
-          const list = stateRef.todoList || [];
-          onEvent?.({ type: "plan", source: "manage_todo_list", operation: "read", todoList: list });
-          return list;
-        }
-        if (Array.isArray(todoList)) {
-          stateRef.todoList = todoList;
-        }
-        const payload = {
-          status: "ok",
-          operation,
-          count: Array.isArray(todoList) ? todoList.length : void 0
-        };
-        onEvent?.({ type: "plan", source: "manage_todo_list", operation: "write", todoList });
-        return payload;
-      },
-      {
-        name: "manage_todo_list",
-        description: "Manage a structured todo list to track progress and plan tasks throughout your coding session. Use this tool VERY frequently to ensure task visibility and proper planning.\n\nWhen to use this tool:\n- Complex multi-step work requiring planning and tracking\n- When user provides multiple tasks or requests (numbered/comma-separated)\n- After receiving new instructions that require multiple steps\n- BEFORE starting work on any todo (mark as in-progress)\n- IMMEDIATELY after completing each todo (mark completed individually)\n- When breaking down larger tasks into smaller actionable steps\n- To give users visibility into your progress and planning\n\nWhen NOT to use:\n- Single, trivial tasks that can be completed in one step\n- Purely conversational/informational requests\n- When just reading files or performing simple searches\n\nCRITICAL workflow:\n1. Plan tasks by writing todo list with specific, actionable items\n2. Complete the work for that specific todo\n3. Mark that todo as completed IMMEDIATELY\n4. Move to next todo and repeat\n\nTodo states:\n- not-started: Todo not yet begun\n- in-progress: Currently working (limit ONE at a time)\n- completed: Finished successfully\n\nIMPORTANT: Mark todos completed as soon as they are done. Do not batch completions.",
-        schema: z2.object({
-          operation: z2.enum(["write", "read"]),
-          todoList: z2.array(z2.object({
-            id: z2.number().int().positive().describe("Sequential id starting from 1"),
-            title: z2.string().min(1),
-            description: z2.string().min(1),
-            status: z2.enum(["not-started", "in-progress", "completed"]),
-            evidence: z2.string().max(200).optional()
-          })).optional()
-        })
-      }
-    );
-    manageTodo._stateRef = stateRef;
-    tools.push(manageTodo);
-  }
-  const getTool = tool2(
-    async ({ executionId }) => {
-      let execution = stateRef.toolHistory?.find((t) => t.executionId === executionId);
-      if (!execution) {
-        execution = stateRef.toolHistoryArchived?.find((t) => t.executionId === executionId);
-      }
-      if (execution) {
-        return execution.rawOutput || execution.output;
-      }
-      return "Execution not found. Please check the executionId.";
-    },
-    {
-      name: "get_tool_response",
-      description: "RETRIEVE tool execution response: Use this to access the full output of a tool execution that shows as 'SUMMARIZED' in the tool history.",
-      schema: z2.object({ executionId: z2.string().describe("Tool execution id") })
-    }
-  );
-  getTool._stateRef = stateRef;
-  tools.push(getTool);
-  if (opts?.outputSchema) {
-    const responseTool = tool2(
-      async (data) => {
-        try {
-          const validated = opts.outputSchema.parse ? opts.outputSchema.parse(data) : data;
-          return { __finalStructuredOutput: true, data: validated };
-        } catch (e) {
-          return { error: "Schema validation failed", details: e?.message };
-        }
-      },
-      {
-        name: "response",
-        description: "Finalize the answer by returning the final structured JSON matching the required schema. Call exactly once when you are fully done, then stop.",
-        // Use schema directly; if not Zod, fall back to any-object
-        schema: opts.outputSchema.shape ? opts.outputSchema : z2.any()
-      }
-    );
-    responseTool._stateRef = stateRef;
-    tools.push(responseTool);
-  }
-  return tools;
-}
-
-// src/graph/decisions.ts
-function needsSummarization(state, opts, summarizationEnabled) {
-  const maxTok = opts.limits?.maxToken;
-  if (!maxTok || !summarizationEnabled) return false;
-  try {
-    const allText = (state.messages || []).map((m) => typeof m.content === "string" ? m.content : Array.isArray(m.content) ? m.content.map((c) => typeof c === "string" ? c : c?.text ?? c?.content ?? "").join("") : "").join("\n");
-    const tokenCount = countApproxTokens(allText);
-    return tokenCount > maxTok;
-  } catch {
-    return false;
-  }
-}
-function resolverDecisionFactory(opts, summarizationEnabled) {
-  return function resolverDecision(state) {
-    return needsSummarization(state, opts, summarizationEnabled) ? "contextSummarize" : "agent";
-  };
-}
-function toolsDecisionFactory(opts, summarizationEnabled) {
-  return function toolsDecision(state) {
-    const max = opts.limits?.maxToolCalls ?? 10;
-    const count = state.toolCallCount || 0;
-    if (count >= max) return "toolLimitFinalize";
-    return needsSummarization(state, opts, summarizationEnabled) ? "contextSummarize" : "agent";
-  };
-}
-
-// src/smart/index.ts
-function createSmartAgent(opts) {
-  const stateRef = { toolHistory: void 0, toolHistoryArchived: void 0, todoList: void 0 };
-  const planningEnabled = opts.useTodoList === true;
-  const contextTools = createContextTools(stateRef, { planningEnabled, outputSchema: void 0 });
-  const mergedTools = [...opts.tools ?? [], ...contextTools];
-  const base = createAgent({ ...opts, tools: mergedTools });
-  const summarizationEnabled = opts.summarization !== false;
-  const summarizer = summarizationEnabled ? createContextSummarizeNode(opts) : void 0;
-  const decideBefore = resolverDecisionFactory(opts, summarizationEnabled);
-  const decideAfter = toolsDecisionFactory(opts, summarizationEnabled);
-  const structuredOutputHint = opts.outputSchema ? [
-    "A structured output schema is active.",
-    "Do NOT output the final JSON directly as an assistant message.",
-    "When completely finished, call tool `response` passing the final JSON matching the schema as its arguments (direct object).",
-    "Call it exactly once then STOP producing further assistant messages."
-  ].join("\n") : "";
-  function systemMessage2() {
-    const sys = buildSystemPrompt(
-      [opts.systemPrompt, structuredOutputHint].filter(Boolean).join("\n"),
-      opts.useTodoList === true,
-      opts.name || "Agent"
-    );
-    return { role: "system", content: sys };
-  }
-  const instance = {
-    invoke: async (input, config) => {
-      stateRef.toolHistory = input.toolHistory;
-      stateRef.toolHistoryArchived = input.toolHistoryArchived;
-      const alreadyHasSystem = Array.isArray(input.messages) && input.messages[0]?.role === "system";
-      const seedMessages = alreadyHasSystem ? [...input.messages || []] : [systemMessage2(), ...input.messages || []];
-      let state = { ...input, messages: seedMessages };
-      let lastResult = null;
-      const iterationLimit = Math.max((opts.limits?.maxToolCalls ?? 10) * 3 + 5, 30);
-      for (let i = 0; i < iterationLimit; i++) {
-        const next = summarizationEnabled ? decideBefore(state) : "agent";
-        if (next === "contextSummarize" && summarizer) {
-          const delta = await summarizer(state);
-          state = { ...state, ...delta };
-          continue;
-        }
-        const res = await base.invoke(state, config);
-        lastResult = res;
-        state = res.state || { ...state, messages: res.messages };
-        if (state.ctx?.__finalizedDueToStructuredOutput) break;
-        if (summarizationEnabled) {
-          const after = decideAfter(state);
-          if (after === "contextSummarize" && summarizer) {
-            const delta = await summarizer(state);
-            state = { ...state, ...delta };
-            continue;
-          }
-        }
-        break;
-      }
-      if (!lastResult) {
-        const res = await base.invoke(state, config);
-        lastResult = res;
-      }
-      return lastResult;
-    },
-    asTool: base.asTool,
-    asHandoff: base.asHandoff,
-    __runtime: base.__runtime
-  };
-  return instance;
-}
-export {
-  applyTokenLimits,
-  buildSystemPrompt,
-  bumpStep,
-  countApproxTokens,
-  createAgent,
-  createAgentNode,
-  createContextSummarizeNode,
-  createContextTools,
-  createDebugSession,
-  createResolverNode,
-  createSmartAgent,
-  createSmartTool,
-  createTool,
-  createToolLimitFinalizeNode,
-  createToolsNode,
-  formatMarkdown,
-  fromLangchainModel,
-  getModelName,
-  isSmartModel,
-  resolveLogsBaseDir,
-  serializeAgentTools,
-  withTools,
-  writeStepMarkdown
-};
-//# sourceMappingURL=index.js.map