@inkeep/agents-api 0.0.0-dev-20260122003353 → 0.0.0-dev-20260122014548

package/dist/domains/run/utils/stream-helpers.d.ts

@@ -12,6 +12,36 @@ interface StreamHelper {
   writeData(type: string, data: any): Promise<void>;
   writeOperation(operation: OperationEvent): Promise<void>;
   writeSummary(summary: SummaryEvent): Promise<void>;
+  writeToolInputStart(params: {
+    toolCallId: string;
+    toolName: string;
+  }): Promise<void>;
+  writeToolInputDelta(params: {
+    toolCallId: string;
+    inputTextDelta: string;
+  }): Promise<void>;
+  writeToolInputAvailable(params: {
+    toolCallId: string;
+    toolName: string;
+    input: any;
+    providerMetadata?: any;
+  }): Promise<void>;
+  writeToolOutputAvailable(params: {
+    toolCallId: string;
+    output: any;
+  }): Promise<void>;
+  writeToolOutputError(params: {
+    toolCallId: string;
+    error: string;
+    output?: any;
+  }): Promise<void>;
+  writeToolApprovalRequest(params: {
+    approvalId: string;
+    toolCallId: string;
+  }): Promise<void>;
+  writeToolOutputDenied(params: {
+    toolCallId: string;
+  }): Promise<void>;
 }
 interface HonoSSEStream {
   writeSSE(message: {
@@ -31,6 +61,15 @@ interface ChatCompletionChunk {
     delta: {
       role?: string;
       content?: string;
+      tool_calls?: Array<{
+        index: number;
+        id: string | null;
+        type: 'function' | null;
+        function: {
+          name: string | null;
+          arguments: string;
+        };
+      }>;
     };
     finish_reason: string | null;
   }>;
@@ -41,6 +80,7 @@ declare class SSEStreamHelper implements StreamHelper {
   private timestamp;
   private isTextStreaming;
   private queuedEvents;
+  private toolCallIndexById;
   constructor(stream: HonoSSEStream, requestId: string, timestamp: number);
   /**
    * Write the initial role message
@@ -50,6 +90,8 @@ declare class SSEStreamHelper implements StreamHelper {
    * Write content chunk
    */
   writeContent(content: string): Promise<void>;
+  private getToolIndex;
+  private writeToolCallsDelta;
   /**
    * Stream text word by word with optional delay
    */
@@ -64,6 +106,36 @@ declare class SSEStreamHelper implements StreamHelper {
    */
   writeCompletion(finishReason?: string): Promise<void>;
   writeData(type: string, data: any): Promise<void>;
+  writeToolInputStart(params: {
+    toolCallId: string;
+    toolName: string;
+  }): Promise<void>;
+  writeToolInputDelta(params: {
+    toolCallId: string;
+    inputTextDelta: string;
+  }): Promise<void>;
+  writeToolInputAvailable(params: {
+    toolCallId: string;
+    toolName: string;
+    input: any;
+    providerMetadata?: any;
+  }): Promise<void>;
+  writeToolOutputAvailable(params: {
+    toolCallId: string;
+    output: any;
+  }): Promise<void>;
+  writeToolOutputError(params: {
+    toolCallId: string;
+    error: string;
+    output?: any;
+  }): Promise<void>;
+  writeToolApprovalRequest(params: {
+    approvalId: string;
+    toolCallId: string;
+  }): Promise<void>;
+  writeToolOutputDenied(params: {
+    toolCallId: string;
+  }): Promise<void>;
   writeSummary(summary: SummaryEvent): Promise<void>;
   writeOperation(operation: OperationEvent): Promise<void>;
   /**
@@ -101,11 +173,42 @@ declare class VercelDataStreamHelper implements StreamHelper {
   private lastTextEndTimestamp;
   private connectionDropTimer?;
   constructor(writer: VercelUIWriter);
+  setSessionId(_sessionId: string): void;
   writeRole(_?: string): Promise<void>;
   writeContent(content: string): Promise<void>;
   streamText(text: string, delayMs?: number): Promise<void>;
   writeData(type: string, data: any): Promise<void>;
   writeError(error: string | ErrorEvent): Promise<void>;
+  writeToolInputStart(params: {
+    toolCallId: string;
+    toolName: string;
+  }): Promise<void>;
+  writeToolInputDelta(params: {
+    toolCallId: string;
+    inputTextDelta: string;
+  }): Promise<void>;
+  writeToolInputAvailable(params: {
+    toolCallId: string;
+    toolName: string;
+    input: any;
+    providerMetadata?: any;
+  }): Promise<void>;
+  writeToolOutputAvailable(params: {
+    toolCallId: string;
+    output: any;
+  }): Promise<void>;
+  writeToolOutputError(params: {
+    toolCallId: string;
+    error: string;
+    output?: any;
+  }): Promise<void>;
+  writeToolApprovalRequest(params: {
+    approvalId: string;
+    toolCallId: string;
+  }): Promise<void>;
+  writeToolOutputDenied(params: {
+    toolCallId: string;
+  }): Promise<void>;
   streamData(data: any): Promise<void>;
   mergeStream(stream: any): Promise<void>;
   /**
@@ -164,6 +267,7 @@ declare class BufferingStreamHelper implements StreamHelper {
   private capturedSummaries;
   private hasError;
   private errorMessage;
+  setSessionId(_sessionId: string): void;
   writeRole(_role?: string): Promise<void>;
   writeContent(content: string): Promise<void>;
   streamText(text: string, _delayMs?: number): Promise<void>;
@@ -174,6 +278,36 @@ declare class BufferingStreamHelper implements StreamHelper {
   writeSummary(summary: SummaryEvent): Promise<void>;
   writeOperation(operation: OperationEvent): Promise<void>;
   writeError(error: string | ErrorEvent): Promise<void>;
+  writeToolInputStart(params: {
+    toolCallId: string;
+    toolName: string;
+  }): Promise<void>;
+  writeToolInputDelta(params: {
+    toolCallId: string;
+    inputTextDelta: string;
+  }): Promise<void>;
+  writeToolInputAvailable(params: {
+    toolCallId: string;
+    toolName: string;
+    input: any;
+    providerMetadata?: any;
+  }): Promise<void>;
+  writeToolOutputAvailable(params: {
+    toolCallId: string;
+    output: any;
+  }): Promise<void>;
+  writeToolOutputError(params: {
+    toolCallId: string;
+    error: string;
+    output?: any;
+  }): Promise<void>;
+  writeToolApprovalRequest(params: {
+    approvalId: string;
+    toolCallId: string;
+  }): Promise<void>;
+  writeToolOutputDenied(params: {
+    toolCallId: string;
+  }): Promise<void>;
   complete(): Promise<void>;
   /**
    * Get the captured response for non-streaming output

package/dist/domains/run/utils/stream-helpers.js

@@ -5,6 +5,7 @@ import { parsePartialJson } from "ai";
 var SSEStreamHelper = class {
 	isTextStreaming = false;
 	queuedEvents = [];
+	toolCallIndexById = /* @__PURE__ */ new Map();
 	constructor(stream, requestId, timestamp) {
 		this.stream = stream;
 		this.requestId = requestId;
@@ -40,6 +41,25 @@ var SSEStreamHelper = class {
 			}]
 		}) });
 	}
+	getToolIndex(toolCallId) {
+		const existing = this.toolCallIndexById.get(toolCallId);
+		if (existing !== void 0) return existing;
+		const next = this.toolCallIndexById.size;
+		this.toolCallIndexById.set(toolCallId, next);
+		return next;
+	}
+	async writeToolCallsDelta(toolCalls) {
+		await this.stream.writeSSE({ data: JSON.stringify({
+			id: this.requestId,
+			object: "chat.completion.chunk",
+			created: this.timestamp,
+			choices: [{
+				index: 0,
+				delta: { tool_calls: toolCalls },
+				finish_reason: null
+			}]
+		}) });
+	}
 	/**
 	* Stream text word by word with optional delay
 	*/
@@ -97,6 +117,65 @@ var SSEStreamHelper = class {
 			}]
 		}) });
 	}
+	async writeToolInputStart(params) {
+		const index = this.getToolIndex(params.toolCallId);
+		await this.writeToolCallsDelta([{
+			index,
+			id: params.toolCallId,
+			type: "function",
+			function: {
+				name: params.toolName,
+				arguments: ""
+			}
+		}]);
+	}
+	async writeToolInputDelta(params) {
+		const index = this.getToolIndex(params.toolCallId);
+		await this.writeToolCallsDelta([{
+			index,
+			id: null,
+			type: null,
+			function: {
+				name: null,
+				arguments: params.inputTextDelta
+			}
+		}]);
+	}
+	async writeToolInputAvailable(params) {
+		const fullArgs = JSON.stringify(params.input ?? {});
+		if (fullArgs) await this.writeToolInputDelta({
+			toolCallId: params.toolCallId,
+			inputTextDelta: fullArgs
+		});
+	}
+	async writeToolOutputAvailable(params) {
+		await this.writeContent(JSON.stringify({
+			type: "tool-output-available",
+			toolCallId: params.toolCallId,
+			output: params.output
+		}));
+	}
+	async writeToolOutputError(params) {
+		await this.writeContent(JSON.stringify({
+			type: "tool-output-error",
+			toolCallId: params.toolCallId,
+			error: params.error,
+			output: params.output ?? null
+		}));
+	}
+	async writeToolApprovalRequest(params) {
+		await this.writeContent(JSON.stringify({
+			type: "tool-approval-request",
+			approvalId: params.approvalId,
+			toolCallId: params.toolCallId
+		}));
+	}
+	async writeToolOutputDenied(params) {
+		await this.writeContent(JSON.stringify({
+			type: "tool-output-denied",
+			toolCallId: params.toolCallId
+		}));
+	}
 	async writeSummary(summary) {
 		if (this.isTextStreaming) {
 			this.queuedEvents.push({
@@ -166,6 +245,7 @@ var VercelDataStreamHelper = class VercelDataStreamHelper {
 			this.forceCleanup("Connection lifetime exceeded");
 		}, STREAM_MAX_LIFETIME_MS);
 	}
+	setSessionId(_sessionId) {}
 	async writeRole(_ = "assistant") {}
 	async writeContent(content) {
 		if (this.isCompleted) {
@@ -272,6 +352,64 @@ var VercelDataStreamHelper = class VercelDataStreamHelper {
 			type: "error"
 		});
 	}
+	async writeToolInputStart(params) {
+		if (this.isCompleted) return;
+		this.writer.write({
+			type: "tool-input-start",
+			toolCallId: params.toolCallId,
+			toolName: params.toolName
+		});
+	}
+	async writeToolInputDelta(params) {
+		if (this.isCompleted) return;
+		this.writer.write({
+			type: "tool-input-delta",
+			toolCallId: params.toolCallId,
+			inputTextDelta: params.inputTextDelta
+		});
+	}
+	async writeToolInputAvailable(params) {
+		if (this.isCompleted) return;
+		this.writer.write({
+			type: "tool-input-available",
+			toolCallId: params.toolCallId,
+			toolName: params.toolName,
+			input: params.input,
+			...params.providerMetadata ? { providerMetadata: params.providerMetadata } : {}
+		});
+	}
+	async writeToolOutputAvailable(params) {
+		if (this.isCompleted) return;
+		this.writer.write({
+			type: "tool-output-available",
+			toolCallId: params.toolCallId,
+			output: params.output
+		});
+	}
+	async writeToolOutputError(params) {
+		if (this.isCompleted) return;
+		this.writer.write({
+			type: "tool-output-error",
+			toolCallId: params.toolCallId,
+			error: params.error,
+			output: params.output ?? null
+		});
+	}
+	async writeToolApprovalRequest(params) {
+		if (this.isCompleted) return;
+		this.writer.write({
+			type: "tool-approval-request",
+			approvalId: params.approvalId,
+			toolCallId: params.toolCallId
+		});
+	}
+	async writeToolOutputDenied(params) {
+		if (this.isCompleted) return;
+		this.writer.write({
+			type: "tool-output-denied",
+			toolCallId: params.toolCallId
+		});
+	}
 	async streamData(data) {
 		await this.writeContent(JSON.stringify(data));
 	}
@@ -458,6 +596,7 @@ var BufferingStreamHelper = class {
 	capturedSummaries = [];
 	hasError = false;
 	errorMessage = "";
+	setSessionId(_sessionId) {}
 	async writeRole(_role) {}
 	async writeContent(content) {
 		this.capturedText += content;
@@ -487,6 +626,49 @@ var BufferingStreamHelper = class {
 		this.hasError = true;
 		this.errorMessage = typeof error === "string" ? error : error.message;
 	}
+	async writeToolInputStart(params) {
+		this.capturedData.push({
+			type: "tool-input-start",
+			...params
+		});
+	}
+	async writeToolInputDelta(params) {
+		this.capturedData.push({
+			type: "tool-input-delta",
+			...params
+		});
+	}
+	async writeToolInputAvailable(params) {
+		this.capturedData.push({
+			type: "tool-input-available",
+			...params
+		});
+	}
+	async writeToolOutputAvailable(params) {
+		this.capturedData.push({
+			type: "tool-output-available",
+			...params
+		});
+	}
+	async writeToolOutputError(params) {
+		this.capturedData.push({
+			type: "tool-output-error",
+			...params,
+			output: params.output ?? null
+		});
+	}
+	async writeToolApprovalRequest(params) {
+		this.capturedData.push({
+			type: "tool-approval-request",
+			...params
+		});
+	}
+	async writeToolOutputDenied(params) {
+		this.capturedData.push({
+			type: "tool-output-denied",
+			...params
+		});
+	}
 	async complete() {}
 	/**
 	* Get the captured response for non-streaming output

package/dist/domains/run/utils/token-estimator.d.ts

@@ -1,4 +1,4 @@
-import * as _inkeep_agents_core3 from "@inkeep/agents-core";
+import * as _inkeep_agents_core1 from "@inkeep/agents-core";
 import { BreakdownComponentDef, ContextBreakdown, calculateBreakdownTotal, createEmptyBreakdown } from "@inkeep/agents-core";
 
 //#region src/domains/run/utils/token-estimator.d.ts
@@ -17,7 +17,7 @@ interface AssembleResult {
   /** The assembled prompt string */
   prompt: string;
   /** Token breakdown for each component */
-  breakdown: _inkeep_agents_core3.ContextBreakdown;
+  breakdown: _inkeep_agents_core1.ContextBreakdown;
 }
 //#endregion
 export { AssembleResult, type BreakdownComponentDef, type ContextBreakdown, calculateBreakdownTotal, createEmptyBreakdown, estimateTokens };

package/dist/factory.d.ts

@@ -3,7 +3,7 @@ import "./types/index.js";
 import { createAgentsHono } from "./createApp.js";
 import { initializeDefaultUser } from "./initialization.js";
 import { createAuth0Provider, createOIDCProvider } from "./ssoHelpers.js";
-import * as hono14 from "hono";
+import * as hono3 from "hono";
 import { CredentialStore, ServerConfig } from "@inkeep/agents-core";
 import * as zod0 from "zod";
 import { SSOProviderConfig, UserAuthConfig } from "@inkeep/agents-core/auth";
@@ -1536,6 +1536,6 @@ declare function createAgentsApp(config?: {
   auth?: UserAuthConfig;
   sandboxConfig?: SandboxConfig;
   skipInitialization?: boolean;
-}): hono14.Hono<hono_types0.BlankEnv, hono_types0.BlankSchema, "/">;
+}): hono3.Hono<hono_types0.BlankEnv, hono_types0.BlankSchema, "/">;
 //#endregion
 export { type SSOProviderConfig, type UserAuthConfig, createAgentsApp, createAgentsAuth, createAgentsHono, createAuth0Provider, createOIDCProvider, initializeDefaultUser };

package/dist/middleware/evalsAuth.d.ts

@@ -1,4 +1,4 @@
-import * as hono0 from "hono";
+import * as hono5 from "hono";
 import { BaseExecutionContext } from "@inkeep/agents-core";
 
 //#region src/middleware/evalsAuth.d.ts
@@ -7,7 +7,7 @@ import { BaseExecutionContext } from "@inkeep/agents-core";
  * Middleware to authenticate API requests using Bearer token authentication
  * First checks if token matches INKEEP_AGENTS_EVAL_API_BYPASS_SECRET,
  */
-declare const evalApiKeyAuth: () => hono0.MiddlewareHandler<{
+declare const evalApiKeyAuth: () => hono5.MiddlewareHandler<{
   Variables: {
     executionContext: BaseExecutionContext;
   };

package/dist/middleware/manageAuth.d.ts

@@ -1,4 +1,4 @@
-import * as hono1 from "hono";
+import * as hono6 from "hono";
 import { BaseExecutionContext } from "@inkeep/agents-core";
 import { createAuth } from "@inkeep/agents-core/auth";
 
@@ -12,7 +12,7 @@ import { createAuth } from "@inkeep/agents-core/auth";
  * 3. Database API key
  * 4. Internal service token
  */
-declare const manageApiKeyAuth: () => hono1.MiddlewareHandler<{
+declare const manageApiKeyAuth: () => hono6.MiddlewareHandler<{
   Variables: {
     executionContext: BaseExecutionContext;
     userId?: string;

package/dist/middleware/projectAccess.d.ts

@@ -1,5 +1,5 @@
 import { ManageAppVariables } from "../types/app.js";
-import * as hono2 from "hono";
+import * as hono7 from "hono";
 
 //#region src/middleware/projectAccess.d.ts
 
@@ -26,6 +26,6 @@ declare const requireProjectPermission: <Env$1 extends {
   Variables: ManageAppVariables;
 } = {
   Variables: ManageAppVariables;
-}>(permission?: ProjectPermission) => hono2.MiddlewareHandler<Env$1, string, {}, Response>;
+}>(permission?: ProjectPermission) => hono7.MiddlewareHandler<Env$1, string, {}, Response>;
 //#endregion
 export { ProjectPermission, requireProjectPermission };

package/dist/middleware/projectConfig.d.ts

@@ -1,11 +1,11 @@
-import * as hono3 from "hono";
+import * as hono11 from "hono";
 import { BaseExecutionContext, ResolvedRef } from "@inkeep/agents-core";
 
 //#region src/middleware/projectConfig.d.ts
 /**
  * Middleware that fetches the full project definition from the Management API
  */
-declare const projectConfigMiddleware: hono3.MiddlewareHandler<{
+declare const projectConfigMiddleware: hono11.MiddlewareHandler<{
   Variables: {
     executionContext: BaseExecutionContext;
     resolvedRef: ResolvedRef;
@@ -15,7 +15,7 @@ declare const projectConfigMiddleware: hono3.MiddlewareHandler<{
  * Creates a middleware that applies project config fetching except for specified route patterns
  * @param skipRouteCheck - Function that returns true if the route should skip the middleware
  */
-declare const projectConfigMiddlewareExcept: (skipRouteCheck: (path: string) => boolean) => hono3.MiddlewareHandler<{
+declare const projectConfigMiddlewareExcept: (skipRouteCheck: (path: string) => boolean) => hono11.MiddlewareHandler<{
   Variables: {
     executionContext: BaseExecutionContext;
     resolvedRef: ResolvedRef;

package/dist/middleware/requirePermission.d.ts

@@ -1,5 +1,5 @@
 import { ManageAppVariables } from "../types/app.js";
-import * as hono5 from "hono";
+import * as hono4 from "hono";
 
 //#region src/middleware/requirePermission.d.ts
 type Permission = {
@@ -9,6 +9,6 @@ declare const requirePermission: <Env$1 extends {
   Variables: ManageAppVariables;
 } = {
   Variables: ManageAppVariables;
-}>(permissions: Permission) => hono5.MiddlewareHandler<Env$1, string, {}, Response>;
+}>(permissions: Permission) => hono4.MiddlewareHandler<Env$1, string, {}, Response>;
 //#endregion
 export { requirePermission };

package/dist/middleware/runAuth.d.ts

@@ -1,8 +1,8 @@
-import * as hono6 from "hono";
+import * as hono8 from "hono";
 import { BaseExecutionContext } from "@inkeep/agents-core";
 
 //#region src/middleware/runAuth.d.ts
-declare const runApiKeyAuth: () => hono6.MiddlewareHandler<{
+declare const runApiKeyAuth: () => hono8.MiddlewareHandler<{
   Variables: {
     executionContext: BaseExecutionContext;
   };
@@ -11,7 +11,7 @@ declare const runApiKeyAuth: () => hono6.MiddlewareHandler<{
  * Creates a middleware that applies API key authentication except for specified route patterns
  * @param skipRouteCheck - Function that returns true if the route should skip authentication
  */
-declare const runApiKeyAuthExcept: (skipRouteCheck: (path: string) => boolean) => hono6.MiddlewareHandler<{
+declare const runApiKeyAuthExcept: (skipRouteCheck: (path: string) => boolean) => hono8.MiddlewareHandler<{
   Variables: {
     executionContext: BaseExecutionContext;
   };
@@ -20,7 +20,7 @@ declare const runApiKeyAuthExcept: (skipRouteCheck: (path: string) => boolean) =
  * Helper middleware for endpoints that optionally support API key authentication
  * If no auth header is present, it continues without setting the executionContext
  */
-declare const runOptionalAuth: () => hono6.MiddlewareHandler<{
+declare const runOptionalAuth: () => hono8.MiddlewareHandler<{
   Variables: {
     executionContext?: BaseExecutionContext;
   };

package/dist/middleware/sessionAuth.d.ts

@@ -1,4 +1,4 @@
-import * as hono9 from "hono";
+import * as hono1 from "hono";
 
 //#region src/middleware/sessionAuth.d.ts
 
@@ -7,11 +7,11 @@ import * as hono9 from "hono";
  * Requires that a user has already been authenticated via Better Auth session.
  * Used primarily for manage routes that require an active user session.
  */
-declare const sessionAuth: () => hono9.MiddlewareHandler<any, string, {}, Response>;
+declare const sessionAuth: () => hono1.MiddlewareHandler<any, string, {}, Response>;
 /**
  * Global session middleware - sets user and session in context for all routes
  * Used for all routes that require an active user session.
  */
-declare const sessionContext: () => hono9.MiddlewareHandler<any, string, {}, Response>;
+declare const sessionContext: () => hono1.MiddlewareHandler<any, string, {}, Response>;
 //#endregion
 export { sessionAuth, sessionContext };

package/dist/middleware/tenantAccess.d.ts

@@ -1,4 +1,4 @@
-import * as hono0 from "hono";
+import * as hono13 from "hono";
 
 //#region src/middleware/tenantAccess.d.ts
 
@@ -11,7 +11,7 @@ import * as hono0 from "hono";
  * - API key user: Access only to the tenant associated with the API key
  * - Session user: Access based on organization membership
  */
-declare const requireTenantAccess: () => hono0.MiddlewareHandler<{
+declare const requireTenantAccess: () => hono13.MiddlewareHandler<{
   Variables: {
     userId: string;
     tenantId: string;

package/dist/middleware/tracing.d.ts

@@ -1,7 +1,7 @@
-import * as hono11 from "hono";
+import * as hono16 from "hono";
 
 //#region src/middleware/tracing.d.ts
-declare const otelBaggageMiddleware: () => hono11.MiddlewareHandler<any, string, {}, Response>;
-declare const executionBaggageMiddleware: () => hono11.MiddlewareHandler<any, string, {}, Response>;
+declare const otelBaggageMiddleware: () => hono16.MiddlewareHandler<any, string, {}, Response>;
+declare const executionBaggageMiddleware: () => hono16.MiddlewareHandler<any, string, {}, Response>;
 //#endregion
 export { executionBaggageMiddleware, otelBaggageMiddleware };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inkeep/agents-api",
-  "version": "0.0.0-dev-20260122003353",
+  "version": "0.0.0-dev-20260122014548",
   "description": "Unified Inkeep Agents API - combines management, runtime, and evaluation capabilities",
   "types": "dist/index.d.ts",
   "exports": {
@@ -70,8 +70,8 @@
     "openid-client": "^6.8.1",
     "pg": "^8.16.3",
     "workflow": "4.0.1-beta.33",
-    "@inkeep/agents-core": "^0.0.0-dev-20260122003353",
-    "@inkeep/agents-manage-mcp": "^0.0.0-dev-20260122003353"
+    "@inkeep/agents-core": "^0.0.0-dev-20260122014548",
+    "@inkeep/agents-manage-mcp": "^0.0.0-dev-20260122014548"
   },
   "peerDependencies": {
     "@hono/zod-openapi": "^1.1.5",