@deepagents/agent 7.0.2 → 7.1.1

package/README.md

@@ -83,9 +83,7 @@ const researcher = agent({
   model: openai('gpt-4o'),
   prompt: 'You research topics and provide detailed information.',
   handoffDescription: 'Handles research and fact-finding tasks',
-  tools: {
-    /* research tools */
-  },
+  tools: {/* research tools */},
 });
 
 const writer = agent({
@@ -142,25 +140,29 @@ console.log(result.output);
 Share state between agents and tools:
 
 ```typescript
-import { tool } from 'ai';
+import { type ToolExecutionOptions, tool } from 'ai';
 import { z } from 'zod';
 
-import { agent, execute, toState } from '@deepagents/agent';
+import { agent, execute } from '@deepagents/agent';
 
-interface AppContext {
+// A `type`, not an `interface`: the AI SDK requires a tool context to
+// extend Record<string, unknown>, which an interface does not.
+type AppContext = {
   userId: string;
   preferences: Record<string, string>;
-}
+};
 
 const preferenceTool = tool({
   description: 'Save user preference',
-  parameters: z.object({
+  inputSchema: z.object({
     key: z.string(),
     value: z.string(),
   }),
-  execute: async ({ key, value }, options) => {
-    const ctx = toState<AppContext>(options);
-    ctx.preferences[key] = value;
+  execute: async (
+    { key, value },
+    { context }: ToolExecutionOptions<AppContext>,
+  ) => {
+    context.preferences[key] = value;
     return `Saved ${key}=${value}`;
   },
 });
@@ -233,9 +235,6 @@ swarm(agent, messages, context, abortSignal?)
 // Create user message
 user(message: string): UIMessage
 
-// Access context in tools
-toState<T>(options: ToolCallOptions): T
-
 // Extract structured output
 toOutput<T>(result): Promise<T>
 ```

package/dist/index.js

@@ -441,9 +441,6 @@ async function finished(iterable) {
 function toOutput(result) {
   return isPromise(result) ? result.then((res) => res.output) : last(result.partialOutputStream);
 }
-function toState(options) {
-  return options.context;
-}
 function toToolsContext(tools, context) {
   return Object.fromEntries(
     Object.keys(tools).map((toolName) => [toolName, context])
@@ -463,7 +460,6 @@ import {
   toUIMessageStream
 } from "ai";
 import chalk2 from "chalk";
-import dedent2 from "dedent";
 async function generate(agent2, messages, contextVariables, config) {
   const tools = agent2.toToolset();
   return generateText2({
@@ -552,7 +548,14 @@ var prepareStep = (agent2, model, contextVariables) => {
       console.error(`Debug: ${chalk2.red("NotFound")}: Agent ${agentName}`);
       console.dir(
         {
-          steps: steps.map(({ request, response, ...etc }) => etc),
+          // Each step without its raw request and response.
+          steps: steps.map(
+            (step2) => Object.fromEntries(
+              Object.entries(step2).filter(
+                ([key]) => key !== "request" && key !== "response"
+              )
+            )
+          ),
           messages
         },
         { depth: null }
@@ -588,14 +591,13 @@ function swarm(agent2, messages, contextVariables, abortSignal) {
       await last(stream2.stream);
       if (!agent2.prepareEnd) return;
       while (true) {
-        const state = contextVariables;
-        if (state.currentActiveAgent === void 0) {
+        if (contextVariables.currentActiveAgent === void 0) {
           console.warn(
             `swarm: active agent was never set, so no prepareEnd call will be made`
           );
           return;
         }
-        if (state.currentActiveAgent === agent2.internalName) {
+        if (contextVariables.currentActiveAgent === agent2.internalName) {
           console.warn(
             `swarm: active agent is the root agent, so no prepareEnd call will be made`
           );
@@ -637,7 +639,6 @@ async function prepareAgent(defaultModel, agent2, messages, contextVariables) {
     activeTools: agent2.toolsNames,
     model: stepModel,
     messages,
-    // messages: removeTransferCalls(messages),
     toolChoice: agent2.toolChoice
   };
 }
@@ -648,25 +649,57 @@ function findAgent(agent2, agentName) {
 }
 
 // packages/agent/src/lib/tool-output.ts
+import { isJSONValue } from "@ai-sdk/provider";
 function withHostOnlyToolMetadata(tools) {
   const wrapped = {};
   for (const [name, tool2] of Object.entries(tools)) {
-    wrapped[name] = tool2.toModelOutput !== void 0 ? tool2 : Object.defineProperties(
+    if (tool2.toModelOutput !== void 0) {
+      wrapped[name] = tool2;
+      continue;
+    }
+    const descriptors = Object.getOwnPropertyDescriptors(tool2);
+    Reflect.deleteProperty(descriptors, "toModelOutput");
+    wrapped[name] = Object.defineProperties(
       {
         ...tool2,
         toModelOutput: ({ output }) => defaultToolModelOutput(output)
       },
-      Object.getOwnPropertyDescriptors(tool2)
+      descriptors
+    );
+  }
+  if (!projectsEveryTool(tools, wrapped)) {
+    throw new Error(
+      "withHostOnlyToolMetadata left a tool without a projection"
     );
   }
   return wrapped;
 }
+function projectsEveryTool(tools, wrapped) {
+  return Object.keys(tools).every(
+    (name) => Object.hasOwn(wrapped, name) && wrapped[name].toModelOutput !== void 0
+  );
+}
 function defaultToolModelOutput(output) {
-  if (typeof output === "object" && output !== null && !Array.isArray(output) && Object.hasOwn(output, "meta")) {
-    const { meta: _meta, ...visible } = output;
-    return { type: "json", value: visible };
+  return typeof output === "string" ? { type: "text", value: output } : { type: "json", value: toJSONValue(withoutMeta(output)) };
+}
+function withoutMeta(output) {
+  if (typeof output !== "object" || output === null || Array.isArray(output) || !Object.hasOwn(output, "meta")) {
+    return output;
   }
-  return typeof output === "string" ? { type: "text", value: output } : { type: "json", value: output ?? null };
+  const visible = { ...output };
+  Reflect.deleteProperty(visible, "meta");
+  return visible;
+}
+function toJSONValue(value) {
+  if (isJSONValue(value)) {
+    return value;
+  }
+  const serialized = JSON.stringify(value);
+  if (serialized === void 0) {
+    return null;
+  }
+  const parsed = JSON.parse(serialized);
+  return isJSONValue(parsed) ? parsed : null;
 }
 
 // packages/agent/src/lib/agent.ts
@@ -717,9 +750,8 @@ var Agent = class _Agent {
           properties: {},
           additionalProperties: true
         }),
-        execute: async (_, options) => {
-          const state = toState(options);
-          state.currentActiveAgent = this.internalName;
+        execute: async (_, { context }) => {
+          context.currentActiveAgent = this.internalName;
           return `Transfer successful to ${this.internalName}.`;
         }
       })
@@ -783,9 +815,12 @@ var Agent = class _Agent {
           "Optional instructions on how the final output should be formatted. this would be passed to the underlying llm as part of the prompt."
         )
       }),
-      execute: async ({ input: input2, output }, options) => {
+      execute: async ({ input: input2, output }, {
+        context: contextVariables,
+        abortSignal
+      }) => {
         try {
-          const contextVariables = options.context;
+          const tools = this.handoff.tools;
           const result = await generateText3({
             model: this.model,
             instructions: this.#prepareInstructions(),
@@ -798,17 +833,12 @@ ${output}
 </OutputInstructions>` : ""}
             `,
             temperature: 0,
-            tools: this.handoff.tools,
-            abortSignal: options.abortSignal,
+            tools,
+            abortSignal,
             stopWhen: isStepCount2(25),
-            repairToolCall: this.repairToolCall(options.abortSignal),
+            repairToolCall: this.repairToolCall(abortSignal),
             runtimeContext: contextVariables,
-            toolsContext: Object.fromEntries(
-              Object.keys(this.handoff.tools).map((toolName) => [
-                toolName,
-                contextVariables
-              ])
-            ),
+            toolsContext: toToolsContext(tools, contextVariables),
             output: this.output ? Output3.object({ schema: this.output }) : void 0,
             onToolExecutionStart: ({ toolCall }) => {
               if (this.logging) {
@@ -872,9 +902,7 @@ ${details}
   }
   clone(agent2) {
     return new _Agent({
-      prepareHandoff: (messages) => {
-        this.prepareHandoff?.(messages);
-      },
+      prepareHandoff: (messages) => this.prepareHandoff?.(messages),
       model: agent2?.model ?? this.model,
       toolChoice: agent2?.toolChoice ?? this.toolChoice,
       prompt: agent2?.prompt ?? this.handoff.instructions,
@@ -991,34 +1019,6 @@ instructions.supervisor_subagent = ({
   }
   return lines.join("\n");
 };
-function isTransferToolResult(call) {
-  if (!call) {
-    return false;
-  }
-  if (typeof call !== "object") {
-    return false;
-  }
-  if (!("output" in call)) {
-    return false;
-  }
-  const lastActiveAgent = call.output.lastActiveAgent;
-  if (!lastActiveAgent) {
-    return false;
-  }
-  return true;
-}
-function lastTransferResult(messages) {
-  for (let i = messages.length - 1; i >= 0; i--) {
-    const message = messages[i];
-    for (let i2 = message.parts.length - 1; i2 >= 0; i2--) {
-      const part = message.parts[i2];
-      if (part.type === "dynamic-tool" && part.toolName.startsWith("transfer_to_") && part.state === "output-available" && isTransferToolResult(part)) {
-        return part.output;
-      }
-    }
-  }
-  return void 0;
-}
 
 // packages/agent/src/lib/models.ts
 import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
@@ -1114,10 +1114,7 @@ function pipe(state, ...processes) {
             await result.consumeStream();
           } else {
             const output = await it(state, (newState) => {
-              Object.assign(
-                state,
-                newState
-              );
+              Object.assign(state, newState);
             });
             if (typeof output === "string") {
               writer.write({
@@ -1161,9 +1158,7 @@ export {
   glm,
   input,
   instructions,
-  isTransferToolResult,
   last,
-  lastTransferResult,
   lmstudio,
   messageToUiMessage,
   minimax,
@@ -1179,7 +1174,6 @@ export {
   swarm,
   thirdPersonPrompt,
   toOutput,
-  toState,
   toToolsContext,
   user,
   withHostOnlyToolMetadata