@mast-ai/core 0.4.0 → 0.6.0

package/dist/adapter/urp.d.ts

@@ -13,6 +13,12 @@ export interface UrpToolCall {
     id: string;
     name: string;
     arguments: unknown;
+    /**
+     * Opaque per-call metadata controlled by the server (e.g. Gemini
+     * `thoughtSignature`). Round-tripped unchanged on the matching
+     * `tool_result` message in the next turn.
+     */
+    provider_metadata?: unknown;
 }
 /** Wire format for a non-streaming URP response. */
 export interface UrpResponse {

package/dist/adapter/urp.js

@@ -40,6 +40,7 @@ export class UrpAdapter {
                     id: tc.id,
                     name: tc.name,
                     args: tc.arguments,
+                    provider_metadata: tc.provider_metadata,
                 }))
                 : [],
         };
@@ -72,6 +73,7 @@ export class UrpAdapter {
                         id: chunk.tool_call.id,
                         name: chunk.tool_call.name,
                         args: chunk.tool_call.arguments,
+                        provider_metadata: chunk.tool_call.provider_metadata,
                     },
                 };
             }

package/dist/runner.js

@@ -194,16 +194,21 @@ export class AgentRunner {
                 }
             }
             if (toolCalls.length > 0) {
+                // Emit tool_call_started only for registered tools so hallucinated
+                // calls never appear in the UI.
                 for (const call of toolCalls) {
-                    yield { type: 'tool_call_started', name: call.name, args: call.args };
+                    if (this.registry.getTool(call.name)) {
+                        yield { type: 'tool_call_started', name: call.name, args: call.args };
+                    }
                 }
                 const toolResults = await Promise.all(toolCalls.map(async (call) => {
                     const tool = this.registry.getTool(call.name);
                     if (!tool) {
                         return {
                             call,
-                            result: `Error: Tool '${call.name}' not found.`,
+                            result: `Tool '${call.name}' does not exist and was not called.`,
                             error: true,
+                            hallucinated: true,
                         };
                     }
                     try {
@@ -211,19 +216,33 @@ export class AgentRunner {
                             signal,
                             onEvent: onToolEvent ? (event) => onToolEvent(call.name, event) : undefined,
                         });
-                        return { call, result, error: false };
+                        return { call, result, error: false, hallucinated: false };
                     }
                     catch (err) {
                         const message = err instanceof Error ? err.message : String(err);
-                        return { call, result: `Error executing tool: ${message}`, error: true };
+                        return {
+                            call,
+                            result: `Error executing tool: ${message}`,
+                            error: true,
+                            hallucinated: false,
+                        };
                     }
                 }));
                 const resultMessages = [];
-                for (const { call, result, error } of toolResults) {
-                    yield { type: 'tool_call_completed', name: call.name, result, error };
+                for (const { call, result, error, hallucinated } of toolResults) {
+                    // Suppress completed events for hallucinated calls — they had no started event.
+                    if (!hallucinated) {
+                        yield { type: 'tool_call_completed', name: call.name, result, error };
+                    }
                     resultMessages.push({
                         role: 'user',
-                        content: { type: 'tool_result', id: call.id, name: call.name, result },
+                        content: {
+                            type: 'tool_result',
+                            id: call.id,
+                            name: call.name,
+                            result,
+                            provider_metadata: call.provider_metadata,
+                        },
                     });
                 }
                 // Assistant tool_calls message must precede tool result messages in history.

package/dist/types.d.ts

@@ -9,6 +9,13 @@ export interface ToolCall {
     id: string;
     name: string;
     args: unknown;
+    /**
+     * Opaque per-call metadata controlled by the adapter / backend
+     * (e.g. Gemini `thoughtSignature`). MAST round-trips this value
+     * unchanged on the matching `tool_result`; it has no schema and
+     * is never inspected by the runner.
+     */
+    provider_metadata?: unknown;
 }
 /**
  * Discriminated union of possible message content types.
@@ -24,6 +31,8 @@ export type MessageContent = {
     id: string;
     name: string;
     result: unknown;
+    /** Copied verbatim from the originating tool call. */
+    provider_metadata?: unknown;
 };
 /**
  * A single message in a conversation history.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mast-ai/core",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "license": "Apache-2.0",
   "type": "module",
   "main": "./dist/index.js",