@cuylabs/agent-core 0.8.0 → 0.10.0

package/dist/{chunk-N6HWIEEA.js → chunk-CMYN2RCB.js}

@@ -1,16 +1,23 @@
 import {
-  executeAgentToolCall
-} from "./chunk-7VKQ4WPB.js";
-import {
-  buildReasoningOptionsSync
-} from "./chunk-SQU2AJHO.js";
-import {
+  executeAgentToolCall,
   snapshotScope
-} from "./chunk-N7P4PN3O.js";
+} from "./chunk-5NVVNXPQ.js";
 import {
   LLMError,
   isRetryable
-} from "./chunk-RZITT45F.js";
+} from "./chunk-N3VX7FEE.js";
+import {
+  buildReasoningOptionsSync,
+  supportsReasoningSync
+} from "./chunk-RN6WZEUF.js";
+import {
+  DEFAULT_MAX_STEPS,
+  DEFAULT_MAX_TOKENS,
+  isBlockedModelCall
+} from "./chunk-CJI7PVS2.js";
+import {
+  formatApprovalDeniedReason
+} from "./chunk-V4RFNEET.js";
 
 // src/inference/toolset.ts
 import { tool, zodSchema } from "ai";
@@ -19,25 +26,58 @@ async function buildToolSet(options) {
   const executionMode = options.executionMode ?? "auto";
   for (const [id, info] of Object.entries(options.tools)) {
     const initialized = await info.init({ cwd: options.cwd });
-    toolSet[id] = executionMode === "auto" ? tool({
-      description: initialized.description,
-      inputSchema: zodSchema(initialized.parameters),
-      execute: async (params) => (await executeAgentToolCall({
-        toolName: id,
-        tool: info,
-        params,
-        cwd: options.cwd,
-        abort: options.abort,
-        sessionID: options.sessionID,
-        messageID: options.messageID,
-        ...options.host ? { host: options.host } : {},
-        ...options.turnTracker ? { turnTracker: options.turnTracker } : {},
-        ...options.middleware ? { middleware: options.middleware } : {}
-      })).output
-    }) : tool({
-      description: initialized.description,
-      inputSchema: zodSchema(initialized.parameters)
-    });
+    const sdkPassthrough = {};
+    if (initialized.title !== void 0) sdkPassthrough.title = initialized.title;
+    if (initialized.strict !== void 0) sdkPassthrough.strict = initialized.strict;
+    if (initialized.inputExamples !== void 0) {
+      sdkPassthrough.inputExamples = initialized.inputExamples;
+    }
+    if (initialized.toModelOutput !== void 0) {
+      sdkPassthrough.toModelOutput = initialized.toModelOutput;
+    }
+    if (executionMode === "auto") {
+      toolSet[id] = tool({
+        description: initialized.description,
+        inputSchema: zodSchema(initialized.parameters),
+        ...sdkPassthrough,
+        execute: async (params, sdkOptions) => {
+          const executed = await executeAgentToolCall({
+            toolName: id,
+            tool: info,
+            initialized,
+            params,
+            cwd: options.cwd,
+            abort: options.abort,
+            sessionID: options.sessionID,
+            turnID: options.turnID,
+            messageID: options.messageID,
+            toolCallId: sdkOptions.toolCallId,
+            ...options.host ? { host: options.host } : {},
+            ...options.humanInputController ? { humanInputController: options.humanInputController } : {},
+            ...options.turnTracker ? { turnTracker: options.turnTracker } : {},
+            ...options.middleware ? { middleware: options.middleware } : {},
+            ...options.onEvent ? { onEvent: options.onEvent } : {}
+          });
+          if (!executed.metadata?.approvalCorrection) {
+            return executed.output;
+          }
+          const structured = {
+            __cuylabsAgentToolResult: true,
+            output: executed.output,
+            metadata: executed.metadata
+          };
+          return structured;
+        }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      });
+    } else {
+      toolSet[id] = tool({
+        description: initialized.description,
+        inputSchema: zodSchema(initialized.parameters),
+        ...sdkPassthrough
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      });
+    }
   }
   return toolSet;
 }
@@ -48,7 +88,115 @@ import {
   streamText
 } from "ai";
 
-// src/retry.ts
+// src/inference/middleware-support.ts
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && Object.getPrototypeOf(value) === Object.prototype;
+}
+function isAsyncIterable(value) {
+  return typeof value === "object" && value !== null && Symbol.asyncIterator in value;
+}
+function stringifyToolOutput(output) {
+  if (typeof output === "string") {
+    return output;
+  }
+  try {
+    const serialized = JSON.stringify(output);
+    return serialized ?? String(output);
+  } catch {
+    return String(output);
+  }
+}
+async function runAfterToolCall(options) {
+  const { middleware, toolName, params, output, ctx } = options;
+  const transformed = await middleware.runAfterToolCall(
+    toolName,
+    params,
+    {
+      title: toolName,
+      output: stringifyToolOutput(output),
+      metadata: {}
+    },
+    ctx
+  );
+  return typeof output === "string" ? transformed.output : output;
+}
+function mergeProviderOptions(base, override) {
+  if (!base) return override;
+  if (!override) return base;
+  const merged = { ...base };
+  for (const [key, value] of Object.entries(override)) {
+    const current = merged[key];
+    merged[key] = isPlainObject(current) && isPlainObject(value) ? mergeProviderOptions(
+      current,
+      value
+    ) : value;
+  }
+  return merged;
+}
+function wrapMcpToolsForMiddleware(options) {
+  const { tools, middleware, cwd, sessionID, turnID, abort, agent } = options;
+  if (!middleware?.hasMiddleware) {
+    return tools;
+  }
+  const wrapped = {};
+  for (const [toolName, tool2] of Object.entries(tools)) {
+    if (!tool2.execute) {
+      wrapped[toolName] = tool2;
+      continue;
+    }
+    wrapped[toolName] = {
+      ...tool2,
+      execute: async (params, execOptions) => {
+        const ctx = {
+          cwd,
+          abort: execOptions.abortSignal ?? abort,
+          sessionID,
+          ...turnID ? { turnID } : {},
+          messageID: execOptions.toolCallId,
+          agent: agent ?? "default",
+          scope: snapshotScope(),
+          extra: {
+            toolCallId: execOptions.toolCallId,
+            messages: execOptions.messages,
+            experimentalContext: execOptions.experimental_context
+          }
+        };
+        const decision = await middleware.runBeforeToolCall(
+          toolName,
+          params,
+          ctx
+        );
+        if (decision.action === "deny") {
+          return decision.reason ?? formatApprovalDeniedReason(toolName);
+        }
+        const result = tool2.execute(params, execOptions);
+        if (isAsyncIterable(result)) {
+          let lastOutput;
+          for await (const chunk of result) {
+            lastOutput = chunk;
+          }
+          return await runAfterToolCall({
+            middleware,
+            toolName,
+            params,
+            output: lastOutput,
+            ctx
+          });
+        }
+        return await runAfterToolCall({
+          middleware,
+          toolName,
+          params,
+          output: await result,
+          ctx
+        });
+      }
+    };
+  }
+  return wrapped;
+}
+
+// src/inference/retry.ts
 var DEFAULT_RETRY_CONFIG = {
   maxAttempts: 3,
   initialDelayMs: 2e3,
@@ -139,14 +287,11 @@ function shouldRetry(error, attempt, maxAttempts = DEFAULT_RETRY_CONFIG.maxAttem
   return isRetryable(error);
 }
 
-// src/inference/types.ts
-var DEFAULT_MAX_OUTPUT_TOKENS = 32e3;
-var OUTPUT_TOKEN_MAX = DEFAULT_MAX_OUTPUT_TOKENS;
-
 // src/inference/stream.ts
 function buildModelCallContext(input) {
   return {
     sessionID: input.sessionID,
+    turnID: input.turnID,
     step: input.step ?? 1,
     cwd: input.cwd,
     abort: input.abort,
@@ -187,14 +332,6 @@ function applyModelCallInput(target, modelCall) {
   target.toolExecutionMode = modelCall.toolExecutionMode;
   target.activeModelCall = modelCall;
 }
-function mergeProviderOptions(base, override) {
-  if (!base) return override;
-  if (!override) return base;
-  return { ...base, ...override };
-}
-function isBlockedModelCall(value) {
-  return "block" in value && value.block === true;
-}
 async function resolveModelCallInput(input) {
   if (!input.middleware?.hasMiddleware) {
     const current = buildModelCallInput(input);
@@ -274,13 +411,20 @@ async function callStreamTextWithOtelContext(options) {
     system: systemParam,
     messages: input.messages,
     tools: allTools,
-    stopWhen: stepCountIs(input.maxSteps ?? 50),
-    maxOutputTokens: input.maxOutputTokens ?? DEFAULT_MAX_OUTPUT_TOKENS,
-    temperature: input.temperature,
-    topP: input.topP,
+    ...input.toolChoice ? { toolChoice: input.toolChoice } : {},
+    ...input.activeTools ? { activeTools: input.activeTools } : {},
+    stopWhen: stepCountIs(input.maxSteps ?? DEFAULT_MAX_STEPS),
+    maxOutputTokens: input.maxOutputTokens ?? DEFAULT_MAX_TOKENS,
+    ...input.temperature !== void 0 && !supportsReasoningSync(input.model) ? { temperature: input.temperature } : {},
+    ...input.topP !== void 0 && !supportsReasoningSync(input.model) ? { topP: input.topP } : {},
     abortSignal: input.abort,
     providerOptions: mergedProviderOptions,
     experimental_telemetry: input.telemetry,
+    // The AI SDK defaults to console.error(error) for stream failures.
+    // We normalize and surface these errors through our own runtime events,
+    // so suppress the duplicate raw dump here.
+    onError: () => {
+    },
     prepareStep: input.intervention ? async ({ messages }) => {
       const pending = input.intervention.drainImmediate();
       if (pending.length === 0) {
@@ -310,7 +454,10 @@ async function callStreamTextWithOtelContext(options) {
       });
     }
   });
-  const otelCtx = input.middleware?.getOtelContext(input.sessionID);
+  const otelCtx = input.middleware?.getOtelContext(input.sessionID, {
+    sessionId: input.sessionID,
+    ...input.turnID ? { turnId: input.turnID } : {}
+  });
   if (!otelCtx) {
     return callStreamText();
   }
@@ -342,26 +489,40 @@ async function stream(input) {
     if (!input.retry || input.retry.maxAttempts === 0) {
       return wrapModelStream(await runCustomStream(), input);
     }
-    return wrapModelStream(await withRetry(
-      async () => await runCustomStream(),
-      input.retry,
-      input.abort
-    ), input);
+    return wrapModelStream(
+      await withRetry(
+        async () => await runCustomStream(),
+        input.retry,
+        input.abort
+      ),
+      input
+    );
   }
   const toolSet = await buildToolSet({
     tools: input.tools,
     cwd: input.cwd,
     sessionID: input.sessionID,
+    turnID: input.turnID,
     messageID,
     abort: input.abort,
     turnTracker: input.turnTracker,
     host: input.host,
+    humanInputController: input.humanInputController,
     middleware: input.middleware,
+    onEvent: input.onEvent,
     executionMode: input.toolExecutionMode
   });
+  const mcpToolSet = wrapMcpToolsForMiddleware({
+    tools: input.mcpTools ?? {},
+    middleware: input.middleware,
+    cwd: input.cwd,
+    sessionID: input.sessionID,
+    turnID: input.turnID,
+    abort: input.abort
+  });
   const allTools = {
     ...toolSet,
-    ...input.mcpTools ?? {}
+    ...mcpToolSet
   };
   const providerOptions = input.reasoningLevel ? buildReasoningOptionsSync(input.model, input.reasoningLevel) : void 0;
   const createStream = async () => {
@@ -379,11 +540,10 @@ async function stream(input) {
   if (!input.retry || input.retry.maxAttempts === 0) {
     return wrapModelStream(await createStream(), input);
   }
-  return wrapModelStream(await withRetry(
-    async () => await createStream(),
-    input.retry,
-    input.abort
-  ), input);
+  return wrapModelStream(
+    await withRetry(async () => await createStream(), input.retry, input.abort),
+    input
+  );
 }
 async function streamOnce(input) {
   return await stream({ ...input, retry: void 0 });
@@ -395,16 +555,75 @@ async function streamStep(input) {
   });
 }
 
+// src/inference/model-messages.ts
+function buildApprovalCorrectionPrompt(correction) {
+  const lines = [
+    `Human approval denied the previous ${correction.tool} tool call.`,
+    `Treat this as corrective guidance and revise the plan before attempting another action.`,
+    `Reason: ${correction.reason}`
+  ];
+  if (correction.feedback) {
+    lines.push(`Feedback: ${correction.feedback}`);
+  }
+  return {
+    role: "system",
+    content: lines.join("\n")
+  };
+}
+function convertAgentMessagesToModelMessages(messages) {
+  return messages.flatMap((message) => {
+    switch (message.role) {
+      case "user":
+        return [{ role: "user", content: message.content }];
+      case "assistant": {
+        if (message.toolCalls && message.toolCalls.length > 0) {
+          const toolCallParts = message.toolCalls.map(
+            (toolCall) => ({
+              type: "tool-call",
+              toolCallId: toolCall.toolCallId,
+              toolName: toolCall.toolName,
+              input: toolCall.args
+            })
+          );
+          return [{ role: "assistant", content: toolCallParts }];
+        }
+        return [{ role: "assistant", content: message.content }];
+      }
+      case "tool":
+        return [
+          {
+            role: "tool",
+            content: [
+              {
+                type: "tool-result",
+                toolCallId: message.toolCallId ?? "",
+                toolName: message.toolName ?? "",
+                output: {
+                  type: "text",
+                  value: typeof message.result === "string" ? message.result : JSON.stringify(message.result)
+                }
+              }
+            ]
+          },
+          ...message.metadata?.approvalCorrection ? [buildApprovalCorrectionPrompt(message.metadata.approvalCorrection)] : []
+        ];
+      case "system":
+        return [{ role: "system", content: message.content }];
+    }
+  });
+}
+
 // src/inference/index.ts
 var Inference = {
+  buildModelCallContext,
   buildToolSet,
   stream,
   streamOnce,
   streamStep
 };
-var LLM = Inference;
 
 export {
+  convertAgentMessagesToModelMessages,
   buildToolSet,
   DEFAULT_RETRY_CONFIG,
   createRetryState,
@@ -413,11 +632,9 @@ export {
   withRetry,
   createRetryHandler,
   shouldRetry,
-  DEFAULT_MAX_OUTPUT_TOKENS,
-  OUTPUT_TOKEN_MAX,
+  buildModelCallContext,
   stream,
   streamOnce,
   streamStep,
-  Inference,
-  LLM
+  Inference
 };

package/dist/chunk-FII65CN7.js

@@ -0,0 +1,117 @@
+// src/safety/patterns.ts
+function matchApprovalPattern(pattern, value) {
+  if (pattern.length > 500) return false;
+  const p = pattern.toLowerCase();
+  const v = value.toLowerCase();
+  let pi = 0;
+  let vi = 0;
+  let starPi = -1;
+  let starVi = -1;
+  while (vi < v.length) {
+    if (pi < p.length && (p[pi] === "?" || p[pi] === v[vi])) {
+      pi++;
+      vi++;
+    } else if (pi < p.length && p[pi] === "*") {
+      starPi = pi;
+      starVi = vi;
+      pi++;
+    } else if (starPi !== -1) {
+      pi = starPi + 1;
+      starVi++;
+      vi = starVi;
+    } else {
+      return false;
+    }
+  }
+  while (pi < p.length && p[pi] === "*") {
+    pi++;
+  }
+  return pi === p.length;
+}
+function extractApprovalPatterns(tool, args) {
+  if (!args || typeof args !== "object") {
+    return [tool];
+  }
+  const record = args;
+  if ("path" in record && typeof record.path === "string" || "filePath" in record && typeof record.filePath === "string") {
+    const path = record.path ?? record.filePath;
+    const dir = path.substring(0, path.lastIndexOf("/") + 1);
+    return [dir ? `${dir}*` : path];
+  }
+  if ("command" in record && typeof record.command === "string") {
+    const command = record.command.split(/\s+/)[0];
+    return [command];
+  }
+  if ("pattern" in record && typeof record.pattern === "string") {
+    return [record.pattern];
+  }
+  return [tool];
+}
+function describeApprovalOperation(tool, args) {
+  if (!args || typeof args !== "object") {
+    return `Execute ${tool}`;
+  }
+  const record = args;
+  switch (tool) {
+    case "read":
+    case "read_file":
+      return `Read file: ${record.path ?? record.filePath}`;
+    case "write":
+    case "write_file":
+    case "create_file":
+      return `Write file: ${record.path ?? record.filePath}`;
+    case "edit":
+    case "edit_file":
+      return `Edit file: ${record.path ?? record.filePath}`;
+    case "delete_file":
+    case "remove":
+      return `Delete: ${record.path}`;
+    case "bash":
+    case "shell": {
+      const command = String(record.command);
+      return `Run command: ${command.slice(0, 100)}${command.length > 100 ? "..." : ""}`;
+    }
+    case "grep":
+      return `Search for: ${record.pattern}`;
+    case "glob":
+      return `Find files: ${record.pattern}`;
+    default: {
+      const json = JSON.stringify(args);
+      const truncated = json.length > 50 ? `${json.slice(0, 50)}...` : json;
+      return `${tool}(${truncated})`;
+    }
+  }
+}
+
+// src/types/tool.ts
+function requiresToolHost(requirements) {
+  if (!requirements) return false;
+  if (requirements.required !== void 0) {
+    return requirements.required;
+  }
+  return requirements.filesystem !== void 0 && requirements.filesystem !== "none" ? true : requirements.shell === true;
+}
+function getRequiredToolHost(ctx, options = {}) {
+  if (ctx.host) {
+    return ctx.host;
+  }
+  const target = options.toolName ? `Tool "${options.toolName}"` : "This tool";
+  const usageSuffix = options.usage ? ` (${options.usage})` : "";
+  throw new Error(
+    `${target} requires an execution host${usageSuffix}, but none was configured.`
+  );
+}
+function resolveCapability(cap, input, fallback) {
+  if (cap === void 0) return fallback;
+  if (typeof cap === "function") return cap(input);
+  return cap;
+}
+
+export {
+  matchApprovalPattern,
+  extractApprovalPatterns,
+  describeApprovalOperation,
+  requiresToolHost,
+  getRequiredToolHost,
+  resolveCapability
+};

package/dist/{chunk-IVUJDISU.js → chunk-GFTW23FV.js}

@@ -1,22 +1,13 @@
 import {
   createSkillRegistry,
   emptySkillRegistry
-} from "./chunk-LRHOS4ZN.js";
+} from "./chunk-SPILYYDF.js";
+import {
+  extractModelId,
+  extractProvider
+} from "./chunk-I6PKJ7XQ.js";
 
 // src/prompt/templates.ts
-function extractModelId(model) {
-  if (typeof model === "string") return model;
-  if (typeof model === "object" && model !== null && "modelId" in model) {
-    return String(model.modelId);
-  }
-  return void 0;
-}
-function extractProvider(model) {
-  if (typeof model === "object" && model !== null && "provider" in model) {
-    return String(model.provider);
-  }
-  return void 0;
-}
 function detectModelFamily(model) {
   const provider = extractProvider(model);
   const modelId = extractModelId(model);