@dexto/tools-builtins 1.6.0 → 1.6.2

package/dist/implementations/ask-user-tool.cjs

@@ -24,21 +24,54 @@ module.exports = __toCommonJS(ask_user_tool_exports);
 var import_zod = require("zod");
 var import_core = require("@dexto/core");
 const AskUserInputSchema = import_zod.z.object({
-  question: import_zod.z.string().describe("The question or prompt to display to the user"),
+  question: import_zod.z.string().describe(
+    "High-level prompt/title for the form. Keep this short; clients may display or ignore it."
+  ),
   schema: import_zod.z.object({
     type: import_zod.z.literal("object"),
-    properties: import_zod.z.record(import_zod.z.unknown()),
+    properties: import_zod.z.record(import_zod.z.string(), import_zod.z.record(import_zod.z.unknown())),
     required: import_zod.z.array(import_zod.z.string()).optional()
   }).passthrough().describe(
-    'JSON Schema defining form fields. Use descriptive property names as labels (e.g., "favorite_team", "World Cup winner country") - NOT generic names like "q1". Use "enum" for dropdowns, "boolean" for yes/no, "number" for numeric inputs, "string" for text. Include "required" array for mandatory fields.'
+    [
+      "JSON Schema defining form fields (object schema only).",
+      "Deterministic UI mapping (recommended):",
+      "- `properties[field].title`: main question/label shown prominently (keep \u2272 80 chars).",
+      "- `properties[field].description`: optional help text (keep \u2272 120 chars).",
+      '- `properties[field]["x-dexto"].stepLabel`: short wizard/step label (keep \u2272 16 chars).',
+      'Use stable, descriptive property keys (avoid generic names like "q1").',
+      "Use `enum` for single-choice lists, `boolean` for yes/no, `number` for numeric inputs, `string` for text.",
+      'For multi-select, use `type: "array"` with `items: { enum: [...] }`.',
+      "Include a top-level `required` array for mandatory fields."
+    ].join(" ")
   )
 }).strict();
+function toTitleCase(value) {
+  return value.trim().replace(/[_-]+/g, " ").replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/\s+/g, " ").split(" ").map((part) => part ? part.charAt(0).toUpperCase() + part.slice(1) : part).join(" ");
+}
+function enrichSchemaTitles(schema) {
+  if (schema.type !== "object") return schema;
+  const properties = schema.properties;
+  if (!properties) return schema;
+  const nextProperties = { ...properties };
+  for (const [key, value] of Object.entries(nextProperties)) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) continue;
+    const title = typeof value.title === "string" ? value.title.trim() : "";
+    if (title) continue;
+    nextProperties[key] = { ...value, title: toTitleCase(key) };
+  }
+  return { ...schema, properties: nextProperties };
+}
 function createAskUserTool() {
   return (0, import_core.defineTool)({
     id: "ask_user",
-    displayName: "Ask",
     description: 'Collect structured input from the user through a form interface. ONLY use this tool when you need: 1) Multiple fields at once (e.g., name + email + preferences), 2) Pre-defined options/choices (use enum for dropdowns like ["small","medium","large"]), 3) Specific data types with validation (boolean for yes/no, number for quantities). DO NOT use for simple conversational questions - just ask those naturally in your response. This tool is for form-like data collection, not chat. Examples: collecting user profile info, configuration settings, or selecting from preset options.',
     inputSchema: AskUserInputSchema,
+    presentation: {
+      describeHeader: (input) => (0, import_core.createLocalToolCallHeader)({
+        title: "Ask",
+        argsText: (0, import_core.truncateForHeader)(input.question, 140)
+      })
+    },
     async execute(input, context) {
       const { question, schema } = input;
       const approvalManager = context.services?.approval;
@@ -48,13 +81,11 @@ function createAskUserTool() {
         );
       }
       const elicitationRequest = {
-        schema,
+        schema: enrichSchemaTitles(input.schema),
         prompt: question,
-        serverName: "Dexto Agent"
+        serverName: "Dexto Agent",
+        ...context.sessionId && { sessionId: context.sessionId }
       };
-      if (context.sessionId !== void 0) {
-        elicitationRequest.sessionId = context.sessionId;
-      }
       return approvalManager.getElicitationData(elicitationRequest);
     }
   });

package/dist/implementations/ask-user-tool.d.ts

@@ -4,22 +4,22 @@ declare const AskUserInputSchema: z.ZodObject<{
     question: z.ZodString;
     schema: z.ZodObject<{
         type: z.ZodLiteral<"object">;
-        properties: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        properties: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         required: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
         type: z.ZodLiteral<"object">;
-        properties: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        properties: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         required: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
         type: z.ZodLiteral<"object">;
-        properties: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        properties: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         required: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     }, z.ZodTypeAny, "passthrough">>;
 }, "strict", z.ZodTypeAny, {
     question: string;
     schema: {
         type: "object";
-        properties: Record<string, unknown>;
+        properties: Record<string, Record<string, unknown>>;
         required?: string[] | undefined;
     } & {
         [k: string]: unknown;
@@ -28,7 +28,7 @@ declare const AskUserInputSchema: z.ZodObject<{
     question: string;
     schema: {
         type: "object";
-        properties: Record<string, unknown>;
+        properties: Record<string, Record<string, unknown>>;
         required?: string[] | undefined;
     } & {
         [k: string]: unknown;

package/dist/implementations/ask-user-tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ask-user-tool.d.ts","sourceRoot":"","sources":["../../src/implementations/ask-user-tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,IAAI,EAAwB,MAAM,aAAa,CAAC;AAE9D,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAcX,CAAC;AAEd;;;;;GAKG;AACH,wBAAgB,iBAAiB,IAAI,IAAI,CAAC,OAAO,kBAAkB,CAAC,CAmCnE"}
+{"version":3,"file":"ask-user-tool.d.ts","sourceRoot":"","sources":["../../src/implementations/ask-user-tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,IAAI,EAAwB,MAAM,aAAa,CAAC;AAE9D,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4BX,CAAC;AAiCd;;;;;GAKG;AACH,wBAAgB,iBAAiB,IAAI,IAAI,CAAC,OAAO,kBAAkB,CAAC,CAiCnE"}

package/dist/implementations/ask-user-tool.js

@@ -1,21 +1,54 @@
 import { z } from "zod";
-import { ToolError, defineTool } from "@dexto/core";
+import { ToolError, createLocalToolCallHeader, defineTool, truncateForHeader } from "@dexto/core";
 const AskUserInputSchema = z.object({
-  question: z.string().describe("The question or prompt to display to the user"),
+  question: z.string().describe(
+    "High-level prompt/title for the form. Keep this short; clients may display or ignore it."
+  ),
   schema: z.object({
     type: z.literal("object"),
-    properties: z.record(z.unknown()),
+    properties: z.record(z.string(), z.record(z.unknown())),
     required: z.array(z.string()).optional()
   }).passthrough().describe(
-    'JSON Schema defining form fields. Use descriptive property names as labels (e.g., "favorite_team", "World Cup winner country") - NOT generic names like "q1". Use "enum" for dropdowns, "boolean" for yes/no, "number" for numeric inputs, "string" for text. Include "required" array for mandatory fields.'
+    [
+      "JSON Schema defining form fields (object schema only).",
+      "Deterministic UI mapping (recommended):",
+      "- `properties[field].title`: main question/label shown prominently (keep \u2272 80 chars).",
+      "- `properties[field].description`: optional help text (keep \u2272 120 chars).",
+      '- `properties[field]["x-dexto"].stepLabel`: short wizard/step label (keep \u2272 16 chars).',
+      'Use stable, descriptive property keys (avoid generic names like "q1").',
+      "Use `enum` for single-choice lists, `boolean` for yes/no, `number` for numeric inputs, `string` for text.",
+      'For multi-select, use `type: "array"` with `items: { enum: [...] }`.',
+      "Include a top-level `required` array for mandatory fields."
+    ].join(" ")
   )
 }).strict();
+function toTitleCase(value) {
+  return value.trim().replace(/[_-]+/g, " ").replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/\s+/g, " ").split(" ").map((part) => part ? part.charAt(0).toUpperCase() + part.slice(1) : part).join(" ");
+}
+function enrichSchemaTitles(schema) {
+  if (schema.type !== "object") return schema;
+  const properties = schema.properties;
+  if (!properties) return schema;
+  const nextProperties = { ...properties };
+  for (const [key, value] of Object.entries(nextProperties)) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) continue;
+    const title = typeof value.title === "string" ? value.title.trim() : "";
+    if (title) continue;
+    nextProperties[key] = { ...value, title: toTitleCase(key) };
+  }
+  return { ...schema, properties: nextProperties };
+}
 function createAskUserTool() {
   return defineTool({
     id: "ask_user",
-    displayName: "Ask",
     description: 'Collect structured input from the user through a form interface. ONLY use this tool when you need: 1) Multiple fields at once (e.g., name + email + preferences), 2) Pre-defined options/choices (use enum for dropdowns like ["small","medium","large"]), 3) Specific data types with validation (boolean for yes/no, number for quantities). DO NOT use for simple conversational questions - just ask those naturally in your response. This tool is for form-like data collection, not chat. Examples: collecting user profile info, configuration settings, or selecting from preset options.',
     inputSchema: AskUserInputSchema,
+    presentation: {
+      describeHeader: (input) => createLocalToolCallHeader({
+        title: "Ask",
+        argsText: truncateForHeader(input.question, 140)
+      })
+    },
     async execute(input, context) {
       const { question, schema } = input;
       const approvalManager = context.services?.approval;
@@ -25,13 +58,11 @@ function createAskUserTool() {
         );
       }
       const elicitationRequest = {
-        schema,
+        schema: enrichSchemaTitles(input.schema),
         prompt: question,
-        serverName: "Dexto Agent"
+        serverName: "Dexto Agent",
+        ...context.sessionId && { sessionId: context.sessionId }
       };
-      if (context.sessionId !== void 0) {
-        elicitationRequest.sessionId = context.sessionId;
-      }
       return approvalManager.getElicitationData(elicitationRequest);
     }
   });

package/dist/implementations/delegate-to-url-tool.cjs

@@ -147,9 +147,14 @@ class SimpleA2AClient {
 function createDelegateToUrlTool() {
   return (0, import_core.defineTool)({
     id: "delegate_to_url",
-    displayName: "Delegate",
     description: 'Delegate a task to another A2A-compliant agent at a specific URL. Supports STATEFUL multi-turn conversations via sessionId parameter. USAGE: (1) First delegation: provide url + message. Tool returns a response AND a sessionId. (2) Follow-up: use the SAME sessionId to continue the conversation with that agent. The agent remembers previous context. EXAMPLE: First call {url: "http://agent:3001", message: "Analyze data X"} returns {sessionId: "xyz", response: "..."}. Second call {url: "http://agent:3001", message: "What was the top insight?", sessionId: "xyz"}. The agent will remember the first analysis and can answer specifically.',
     inputSchema: DelegateToUrlInputSchema,
+    presentation: {
+      describeHeader: (input) => (0, import_core.createLocalToolCallHeader)({
+        title: "Delegate",
+        argsText: (0, import_core.truncateForHeader)(`${input.url} ${input.message}`, 140)
+      })
+    },
     async execute(input, _context) {
       const { url, message, sessionId, timeout } = input;
       try {

package/dist/implementations/delegate-to-url-tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"delegate-to-url-tool.d.ts","sourceRoot":"","sources":["../../src/implementations/delegate-to-url-tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,IAAI,EAAwB,MAAM,aAAa,CAAC;AAG9D,QAAA,MAAM,wBAAwB;;;;;;;;;;;;;;;EA0BjB,CAAC;AAsJd;;;;GAIG;AACH,wBAAgB,uBAAuB,IAAI,IAAI,CAAC,OAAO,wBAAwB,CAAC,CAyC/E"}
+{"version":3,"file":"delegate-to-url-tool.d.ts","sourceRoot":"","sources":["../../src/implementations/delegate-to-url-tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,IAAI,EAAwB,MAAM,aAAa,CAAC;AAU9D,QAAA,MAAM,wBAAwB;;;;;;;;;;;;;;;EA0BjB,CAAC;AAsJd;;;;GAIG;AACH,wBAAgB,uBAAuB,IAAI,IAAI,CAAC,OAAO,wBAAwB,CAAC,CA+C/E"}

package/dist/implementations/delegate-to-url-tool.js

@@ -1,5 +1,12 @@
 import { z } from "zod";
-import { DextoRuntimeError, ErrorScope, ErrorType, defineTool } from "@dexto/core";
+import {
+  DextoRuntimeError,
+  ErrorScope,
+  ErrorType,
+  createLocalToolCallHeader,
+  defineTool,
+  truncateForHeader
+} from "@dexto/core";
 const DelegateToUrlInputSchema = z.object({
   url: z.string().url().describe(
     'The A2A-compliant agent URL (e.g., "http://localhost:3001" or "https://agent.example.com"). The tool will automatically append the correct JSON-RPC endpoint.'
@@ -124,9 +131,14 @@ class SimpleA2AClient {
 function createDelegateToUrlTool() {
   return defineTool({
     id: "delegate_to_url",
-    displayName: "Delegate",
     description: 'Delegate a task to another A2A-compliant agent at a specific URL. Supports STATEFUL multi-turn conversations via sessionId parameter. USAGE: (1) First delegation: provide url + message. Tool returns a response AND a sessionId. (2) Follow-up: use the SAME sessionId to continue the conversation with that agent. The agent remembers previous context. EXAMPLE: First call {url: "http://agent:3001", message: "Analyze data X"} returns {sessionId: "xyz", response: "..."}. Second call {url: "http://agent:3001", message: "What was the top insight?", sessionId: "xyz"}. The agent will remember the first analysis and can answer specifically.',
     inputSchema: DelegateToUrlInputSchema,
+    presentation: {
+      describeHeader: (input) => createLocalToolCallHeader({
+        title: "Delegate",
+        argsText: truncateForHeader(`${input.url} ${input.message}`, 140)
+      })
+    },
     async execute(input, _context) {
       const { url, message, sessionId, timeout } = input;
       try {

package/dist/implementations/delegate-to-url-tool.test.cjs

@@ -11,6 +11,7 @@ function createMockLogger() {
     error: import_vitest.vi.fn(),
     trackException: import_vitest.vi.fn(),
     createChild: import_vitest.vi.fn(() => logger),
+    createFileOnlyChild: import_vitest.vi.fn(() => logger),
     setLevel: import_vitest.vi.fn(),
     getLevel: import_vitest.vi.fn(() => "debug"),
     getLogFilePath: import_vitest.vi.fn(() => null),

package/dist/implementations/delegate-to-url-tool.test.js

@@ -10,6 +10,7 @@ function createMockLogger() {
     error: vi.fn(),
     trackException: vi.fn(),
     createChild: vi.fn(() => logger),
+    createFileOnlyChild: vi.fn(() => logger),
     setLevel: vi.fn(),
     getLevel: vi.fn(() => "debug"),
     getLogFilePath: vi.fn(() => null),

package/dist/implementations/exa-code-search-tool.cjs

@@ -33,9 +33,14 @@ const CodeSearchInputSchema = import_zod.z.object({
 function createCodeSearchTool() {
   return (0, import_core.defineTool)({
     id: "code_search",
-    displayName: "Code Search",
     description: "Search for code examples and documentation across sources like official docs, GitHub, and Stack Overflow. Returns formatted text context.",
     inputSchema: CodeSearchInputSchema,
+    presentation: {
+      describeHeader: (input) => (0, import_core.createLocalToolCallHeader)({
+        title: "Code Search",
+        argsText: (0, import_core.truncateForHeader)(input.query, 140)
+      })
+    },
     async execute(input, context) {
       const { query, tokensNum } = input;
       return await (0, import_exa_mcp.callExaTool)({

package/dist/implementations/exa-code-search-tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"exa-code-search-tool.d.ts","sourceRoot":"","sources":["../../src/implementations/exa-code-search-tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,IAAI,EAAwB,MAAM,aAAa,CAAC;AAG9D,QAAA,MAAM,qBAAqB;;;;;;;;;EAiBd,CAAC;AACd;;;;GAIG;AACH,wBAAgB,oBAAoB,IAAI,IAAI,CAAC,OAAO,qBAAqB,CAAC,CAsBzE"}
+{"version":3,"file":"exa-code-search-tool.d.ts","sourceRoot":"","sources":["../../src/implementations/exa-code-search-tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,IAAI,EAAwB,MAAM,aAAa,CAAC;AAG9D,QAAA,MAAM,qBAAqB;;;;;;;;;EAiBd,CAAC;AACd;;;;GAIG;AACH,wBAAgB,oBAAoB,IAAI,IAAI,CAAC,OAAO,qBAAqB,CAAC,CA4BzE"}

package/dist/implementations/exa-code-search-tool.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { defineTool } from "@dexto/core";
+import { createLocalToolCallHeader, defineTool, truncateForHeader } from "@dexto/core";
 import { callExaTool } from "./exa-mcp.js";
 const CodeSearchInputSchema = z.object({
   query: z.string().min(1).describe(
@@ -10,9 +10,14 @@ const CodeSearchInputSchema = z.object({
 function createCodeSearchTool() {
   return defineTool({
     id: "code_search",
-    displayName: "Code Search",
     description: "Search for code examples and documentation across sources like official docs, GitHub, and Stack Overflow. Returns formatted text context.",
     inputSchema: CodeSearchInputSchema,
+    presentation: {
+      describeHeader: (input) => createLocalToolCallHeader({
+        title: "Code Search",
+        argsText: truncateForHeader(input.query, 140)
+      })
+    },
     async execute(input, context) {
       const { query, tokensNum } = input;
       return await callExaTool({

package/dist/implementations/exa-tools.test.cjs

@@ -12,6 +12,7 @@ function createMockLogger() {
     error: import_vitest.vi.fn(),
     trackException: import_vitest.vi.fn(),
     createChild: import_vitest.vi.fn(() => logger),
+    createFileOnlyChild: import_vitest.vi.fn(() => logger),
     setLevel: import_vitest.vi.fn(),
     getLevel: import_vitest.vi.fn(() => "debug"),
     getLogFilePath: import_vitest.vi.fn(() => null),

package/dist/implementations/exa-tools.test.js

@@ -11,6 +11,7 @@ function createMockLogger() {
     error: vi.fn(),
     trackException: vi.fn(),
     createChild: vi.fn(() => logger),
+    createFileOnlyChild: vi.fn(() => logger),
     setLevel: vi.fn(),
     getLevel: vi.fn(() => "debug"),
     getLogFilePath: vi.fn(() => null),

package/dist/implementations/exa-web-search-tool.cjs

@@ -36,9 +36,14 @@ const WebSearchInputSchema = import_zod.z.object({
 function createWebSearchTool() {
   return (0, import_core.defineTool)({
     id: "web_search",
-    displayName: "Web Search",
     description: "Search the web for current information and return clean, ready-to-use text. Use for news, facts, and up-to-date context.",
     inputSchema: WebSearchInputSchema,
+    presentation: {
+      describeHeader: (input) => (0, import_core.createLocalToolCallHeader)({
+        title: "Web Search",
+        argsText: (0, import_core.truncateForHeader)(input.query, 140)
+      })
+    },
     async execute(input, context) {
       const { query, numResults, livecrawl, type, contextMaxCharacters } = input;
       return await (0, import_exa_mcp.callExaTool)({

package/dist/implementations/exa-web-search-tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"exa-web-search-tool.d.ts","sourceRoot":"","sources":["../../src/implementations/exa-web-search-tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,IAAI,EAAwB,MAAM,aAAa,CAAC;AAG9D,QAAA,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;EA8Bb,CAAC;AACd;;;;GAIG;AACH,wBAAgB,mBAAmB,IAAI,IAAI,CAAC,OAAO,oBAAoB,CAAC,CAyBvE"}
+{"version":3,"file":"exa-web-search-tool.d.ts","sourceRoot":"","sources":["../../src/implementations/exa-web-search-tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,IAAI,EAAwB,MAAM,aAAa,CAAC;AAG9D,QAAA,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;EA8Bb,CAAC;AACd;;;;GAIG;AACH,wBAAgB,mBAAmB,IAAI,IAAI,CAAC,OAAO,oBAAoB,CAAC,CA+BvE"}

package/dist/implementations/exa-web-search-tool.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { defineTool } from "@dexto/core";
+import { createLocalToolCallHeader, defineTool, truncateForHeader } from "@dexto/core";
 import { callExaTool } from "./exa-mcp.js";
 const WebSearchInputSchema = z.object({
   query: z.string().min(1).describe("Web search query"),
@@ -13,9 +13,14 @@ const WebSearchInputSchema = z.object({
 function createWebSearchTool() {
   return defineTool({
     id: "web_search",
-    displayName: "Web Search",
     description: "Search the web for current information and return clean, ready-to-use text. Use for news, facts, and up-to-date context.",
     inputSchema: WebSearchInputSchema,
+    presentation: {
+      describeHeader: (input) => createLocalToolCallHeader({
+        title: "Web Search",
+        argsText: truncateForHeader(input.query, 140)
+      })
+    },
     async execute(input, context) {
       const { query, numResults, livecrawl, type, contextMaxCharacters } = input;
       return await callExaTool({

package/dist/implementations/get-resource-tool.cjs

@@ -34,9 +34,17 @@ const GetResourceInputSchema = import_zod.z.object({
 function createGetResourceTool() {
   return (0, import_core.defineTool)({
     id: "get_resource",
-    displayName: "Get Resource",
     description: 'Access a stored resource. Use format "url" to get a shareable URL for other agents or external systems (requires remote storage like Supabase). Use format "metadata" to get resource information without loading data. References can be obtained from tool result annotations or list_resources.',
     inputSchema: GetResourceInputSchema,
+    presentation: {
+      describeHeader: (input) => (0, import_core.createLocalToolCallHeader)({
+        title: "Get Resource",
+        argsText: (0, import_core.truncateForHeader)(
+          input.format === "metadata" ? `${input.reference} (metadata)` : input.reference,
+          140
+        )
+      })
+    },
     async execute(input, context) {
       const { reference, format } = input;
       const resourceManager = context.services?.resources;

package/dist/implementations/get-resource-tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"get-resource-tool.d.ts","sourceRoot":"","sources":["../../src/implementations/get-resource-tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,IAAI,EAAwB,MAAM,aAAa,CAAC;AAE9D,QAAA,MAAM,sBAAsB;;;;;;;;;EAgBf,CAAC;AAEd;;;;;GAKG;AACH,wBAAgB,qBAAqB,IAAI,IAAI,CAAC,OAAO,sBAAsB,CAAC,CAsG3E"}
+{"version":3,"file":"get-resource-tool.d.ts","sourceRoot":"","sources":["../../src/implementations/get-resource-tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,IAAI,EAAwB,MAAM,aAAa,CAAC;AAE9D,QAAA,MAAM,sBAAsB;;;;;;;;;EAgBf,CAAC;AAEd;;;;;GAKG;AACH,wBAAgB,qBAAqB,IAAI,IAAI,CAAC,OAAO,sBAAsB,CAAC,CAiH3E"}

package/dist/implementations/get-resource-tool.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { ToolError, defineTool } from "@dexto/core";
+import { ToolError, createLocalToolCallHeader, defineTool, truncateForHeader } from "@dexto/core";
 const GetResourceInputSchema = z.object({
   reference: z.string().describe(
     'The resource reference to access. Formats: "blob:abc123" (from list_resources), "resource_ref:blob:abc123" (from tool annotations)'
@@ -11,9 +11,17 @@ const GetResourceInputSchema = z.object({
 function createGetResourceTool() {
   return defineTool({
     id: "get_resource",
-    displayName: "Get Resource",
     description: 'Access a stored resource. Use format "url" to get a shareable URL for other agents or external systems (requires remote storage like Supabase). Use format "metadata" to get resource information without loading data. References can be obtained from tool result annotations or list_resources.',
     inputSchema: GetResourceInputSchema,
+    presentation: {
+      describeHeader: (input) => createLocalToolCallHeader({
+        title: "Get Resource",
+        argsText: truncateForHeader(
+          input.format === "metadata" ? `${input.reference} (metadata)` : input.reference,
+          140
+        )
+      })
+    },
     async execute(input, context) {
       const { reference, format } = input;
       const resourceManager = context.services?.resources;

package/dist/implementations/http-request-tool.cjs

@@ -18,7 +18,8 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var http_request_tool_exports = {};
 __export(http_request_tool_exports, {
-  createHttpRequestTool: () => createHttpRequestTool
+  createHttpRequestTool: () => createHttpRequestTool,
+  createSafeLookup: () => createSafeLookup
 });
 module.exports = __toCommonJS(http_request_tool_exports);
 var import_zod = require("zod");
@@ -96,61 +97,101 @@ function isPrivateAddress(ip) {
   if (version === 6) return isPrivateIpv6(ip);
   return false;
 }
-function createSafeDispatcher() {
-  const lookup = (hostname, _options, callback) => {
+function createSafeLookup(config) {
+  const dnsLookup = config?.dnsLookup ?? import_node_dns.promises.lookup;
+  return (hostname, options, callback) => {
     void (async () => {
+      const toErrnoException = (err) => err;
+      const emitError = (err) => {
+        try {
+          if (options.all) {
+            callback(err, []);
+            return;
+          }
+          callback(err, "", 0);
+        } catch {
+        }
+      };
       try {
         if (BLOCKED_HOSTNAMES.has(hostname) || hostname.endsWith(".localhost")) {
-          callback(
-            new import_core.DextoRuntimeError(
-              "HTTP_REQUEST_UNSAFE_TARGET",
-              import_core.ErrorScope.TOOLS,
-              import_core.ErrorType.FORBIDDEN,
-              `Blocked request to local hostname: ${hostname}`
-            ),
-            "",
-            0
+          emitError(
+            toErrnoException(
+              new import_core.DextoRuntimeError(
+                "HTTP_REQUEST_UNSAFE_TARGET",
+                import_core.ErrorScope.TOOLS,
+                import_core.ErrorType.FORBIDDEN,
+                `Blocked request to local hostname: ${hostname}`
+              )
+            )
           );
           return;
         }
-        const records = await import_node_dns.promises.lookup(hostname, {
+        const records = await dnsLookup(hostname, {
           all: true,
-          verbatim: true
+          verbatim: true,
+          family: options.family,
+          hints: options.hints
         });
         if (!records.length) {
-          callback(
-            new import_core.DextoRuntimeError(
-              "HTTP_REQUEST_DNS_FAILED",
-              import_core.ErrorScope.TOOLS,
-              import_core.ErrorType.THIRD_PARTY,
-              `Failed to resolve hostname: ${hostname}`
-            ),
-            "",
-            0
+          emitError(
+            toErrnoException(
+              new import_core.DextoRuntimeError(
+                "HTTP_REQUEST_DNS_FAILED",
+                import_core.ErrorScope.TOOLS,
+                import_core.ErrorType.THIRD_PARTY,
+                `Failed to resolve hostname: ${hostname}`
+              )
+            )
           );
           return;
         }
         for (const record of records) {
           if (isPrivateAddress(record.address)) {
-            callback(
-              new import_core.DextoRuntimeError(
-                "HTTP_REQUEST_UNSAFE_TARGET",
-                import_core.ErrorScope.TOOLS,
-                import_core.ErrorType.FORBIDDEN,
-                `Blocked request to private address: ${record.address}`
-              ),
-              "",
-              0
+            emitError(
+              toErrnoException(
+                new import_core.DextoRuntimeError(
+                  "HTTP_REQUEST_UNSAFE_TARGET",
+                  import_core.ErrorScope.TOOLS,
+                  import_core.ErrorType.FORBIDDEN,
+                  `Blocked request to private address: ${record.address}`
+                )
+              )
             );
             return;
           }
         }
+        if (options.all) {
+          try {
+            callback(
+              null,
+              records
+            );
+          } catch {
+          }
+          return;
+        }
         const selected = records[0];
-        callback(
-          null,
-          selected.address,
-          selected.family ?? ((0, import_node_net.isIP)(selected.address) === 6 ? 6 : 4)
-        );
+        if (!selected) {
+          emitError(
+            toErrnoException(
+              new import_core.DextoRuntimeError(
+                "HTTP_REQUEST_DNS_FAILED",
+                import_core.ErrorScope.TOOLS,
+                import_core.ErrorType.THIRD_PARTY,
+                `Failed to resolve hostname: ${hostname}`
+              )
+            )
+          );
+          return;
+        }
+        try {
+          callback(
+            null,
+            selected.address,
+            selected.family ?? ((0, import_node_net.isIP)(selected.address) === 6 ? 6 : 4)
+          );
+        } catch {
+        }
       } catch (error) {
         const err = error instanceof import_core.DextoRuntimeError ? error : new import_core.DextoRuntimeError(
           "HTTP_REQUEST_DNS_FAILED",
@@ -158,10 +199,13 @@ function createSafeDispatcher() {
           import_core.ErrorType.THIRD_PARTY,
           `Failed to resolve hostname: ${hostname}`
         );
-        callback(err, "", 0);
+        emitError(toErrnoException(err));
       }
     })();
   };
+}
+function createSafeDispatcher() {
+  const lookup = createSafeLookup();
   return new import_undici.Agent({ connect: { lookup } });
 }
 async function assertSafeUrl(requestUrl) {
@@ -241,9 +285,14 @@ async function readResponseTextWithLimit(response) {
 function createHttpRequestTool() {
   return (0, import_core.defineTool)({
     id: "http_request",
-    displayName: "Fetch",
     description: "Make a direct HTTP request using fetch. Supports method, headers, query params, JSON bodies, and timeouts. Returns status, headers, raw body text, and parsed JSON when available.",
     inputSchema: HttpRequestInputSchema,
+    presentation: {
+      describeHeader: (input) => (0, import_core.createLocalToolCallHeader)({
+        title: "Fetch",
+        argsText: (0, import_core.truncateForHeader)(input.url, 140)
+      })
+    },
     async execute(input, _context) {
       const { url, method, headers, query, body, timeoutMs } = input;
       const requestUrl = new URL(url);
@@ -323,5 +372,6 @@ function createHttpRequestTool() {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  createHttpRequestTool
+  createHttpRequestTool,
+  createSafeLookup
 });

package/dist/implementations/http-request-tool.d.ts

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import type { Tool } from '@dexto/core';
+import { promises as dns, type LookupAddress, type LookupOptions } from 'node:dns';
 declare const HttpRequestInputSchema: z.ZodObject<{
     url: z.ZodString;
     method: z.ZodDefault<z.ZodEnum<["GET", "POST", "PUT", "PATCH", "DELETE"]>>;
@@ -22,6 +23,10 @@ declare const HttpRequestInputSchema: z.ZodObject<{
     body?: string | unknown[] | Record<string, unknown> | undefined;
     timeoutMs?: number | undefined;
 }>;
+type LookupCallback = ((err: NodeJS.ErrnoException | null, address: string, family: number) => void) | ((err: NodeJS.ErrnoException | null, addresses: LookupAddress[]) => void);
+export declare function createSafeLookup(config?: {
+    dnsLookup?: typeof dns.lookup;
+}): (hostname: string, options: LookupOptions, callback: LookupCallback) => void;
 /**
  * Internal tool for basic HTTP requests.
  */

package/dist/implementations/http-request-tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"http-request-tool.d.ts","sourceRoot":"","sources":["../../src/implementations/http-request-tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,IAAI,EAAwB,MAAM,aAAa,CAAC;AAO9D,QAAA,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;EA2Bf,CAAC;AAmPd;;GAEG;AACH,wBAAgB,qBAAqB,IAAI,IAAI,CAAC,OAAO,sBAAsB,CAAC,CAiG3E"}
+{"version":3,"file":"http-request-tool.d.ts","sourceRoot":"","sources":["../../src/implementations/http-request-tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,IAAI,EAAwB,MAAM,aAAa,CAAC;AAS9D,OAAO,EAAE,QAAQ,IAAI,GAAG,EAAE,KAAK,aAAa,EAAE,KAAK,aAAa,EAAE,MAAM,UAAU,CAAC;AAKnF,QAAA,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;EA2Bf,CAAC;AA8Bd,KAAK,cAAc,GACb,CAAC,CAAC,GAAG,EAAE,MAAM,CAAC,cAAc,GAAG,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC,GAC9E,CAAC,CAAC,GAAG,EAAE,MAAM,CAAC,cAAc,GAAG,IAAI,EAAE,SAAS,EAAE,aAAa,EAAE,KAAK,IAAI,CAAC,CAAC;AAoDhF,wBAAgB,gBAAgB,CAAC,MAAM,CAAC,EAAE;IACtC,SAAS,CAAC,EAAE,OAAO,GAAG,CAAC,MAAM,CAAC;CACjC,GAAG,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,aAAa,EAAE,QAAQ,EAAE,cAAc,KAAK,IAAI,CAyI/E;AA2FD;;GAEG;AACH,wBAAgB,qBAAqB,IAAI,IAAI,CAAC,OAAO,sBAAsB,CAAC,CAuG3E"}