@inkeep/agents-sdk 0.39.4 → 0.40.0

package/dist/projectFullClient.js

@@ -0,0 +1,162 @@
+import { apiFetch, getLogger } from "@inkeep/agents-core";
+
+//#region src/projectFullClient.ts
+/**
+* Client-side functions for interacting with the Full Project API
+* These functions make HTTP requests to the server instead of direct database calls
+*/
+const logger = getLogger("projectFullClient");
+/**
+* Create a full project via HTTP API
+*/
+async function createFullProjectViaAPI(tenantId, apiUrl, projectData, apiKey) {
+	logger.info({
+		tenantId,
+		projectId: projectData.id,
+		apiUrl
+	}, "Creating full project via API");
+	const url = `${apiUrl}/tenants/${tenantId}/project-full`;
+	const headers = {};
+	if (apiKey) headers.Authorization = `Bearer ${apiKey}`;
+	let response;
+	try {
+		response = await apiFetch(url, {
+			method: "POST",
+			headers,
+			body: JSON.stringify(projectData)
+		});
+	} catch (fetchError) {
+		logger.error({
+			error: fetchError instanceof Error ? fetchError.message : "Unknown fetch error",
+			url,
+			tenantId,
+			projectId: projectData.id
+		}, "Fetch request failed");
+		throw fetchError;
+	}
+	if (!response.ok) {
+		const errorMessage = parseError(await response.text()) ?? `Failed to create project: ${response.status} ${response.statusText}`;
+		logger.error({
+			status: response.status,
+			error: errorMessage
+		}, "Failed to create project via API");
+		throw new Error(errorMessage);
+	}
+	const result = await response.json();
+	logger.info({ projectId: projectData.id }, "Successfully created project via API");
+	return result.data;
+}
+/**
+* Update a full project via HTTP API (upsert behavior)
+*/
+async function updateFullProjectViaAPI(tenantId, apiUrl, projectId, projectData, apiKey) {
+	logger.info({
+		tenantId,
+		projectId,
+		apiUrl
+	}, "Updating full project via API");
+	const url = `${apiUrl}/tenants/${tenantId}/project-full/${projectId}`;
+	const headers = {};
+	if (apiKey) headers.Authorization = `Bearer ${apiKey}`;
+	let response;
+	try {
+		response = await apiFetch(url, {
+			method: "PUT",
+			headers,
+			body: JSON.stringify(projectData)
+		});
+	} catch (fetchError) {
+		logger.error({
+			error: fetchError instanceof Error ? fetchError.message : "Unknown fetch error",
+			url,
+			tenantId,
+			projectId
+		}, "Fetch request failed");
+		throw fetchError;
+	}
+	if (!response.ok) {
+		const errorMessage = parseError(await response.text()) ?? `Failed to update project: ${response.status} ${response.statusText}`;
+		logger.error({
+			status: response.status,
+			error: errorMessage
+		}, "Failed to update project via API");
+		throw new Error(errorMessage);
+	}
+	const result = await response.json();
+	logger.info({ projectId }, "Successfully updated project via API");
+	return result.data;
+}
+/**
+* Get a full project via HTTP API
+*/
+async function getFullProjectViaAPI(tenantId, apiUrl, projectId, apiKey) {
+	logger.info({
+		tenantId,
+		projectId,
+		apiUrl
+	}, "Getting full project via API");
+	const url = `${apiUrl}/tenants/${tenantId}/project-full/${projectId}`;
+	const headers = {};
+	if (apiKey) headers.Authorization = `Bearer ${apiKey}`;
+	const response = await apiFetch(url, {
+		method: "GET",
+		headers
+	});
+	if (!response.ok) {
+		if (response.status === 404) {
+			logger.info({ projectId }, "Project not found");
+			return null;
+		}
+		const errorMessage = parseError(await response.text()) ?? `Failed to get project: ${response.status} ${response.statusText}`;
+		logger.error({
+			status: response.status,
+			error: errorMessage
+		}, "Failed to get project via API");
+		throw new Error(errorMessage);
+	}
+	const result = await response.json();
+	logger.info({ projectId }, "Successfully retrieved project via API");
+	return result.data;
+}
+/**
+* Delete a full project via HTTP API
+*/
+async function deleteFullProjectViaAPI(tenantId, apiUrl, projectId, apiKey) {
+	logger.info({
+		tenantId,
+		projectId,
+		apiUrl
+	}, "Deleting full project via API");
+	const url = `${apiUrl}/tenants/${tenantId}/project-full/${projectId}`;
+	const headers = {};
+	if (apiKey) headers.Authorization = `Bearer ${apiKey}`;
+	const response = await apiFetch(url, {
+		method: "DELETE",
+		headers
+	});
+	if (!response.ok) {
+		const errorMessage = parseError(await response.text()) ?? `Failed to delete project: ${response.status} ${response.statusText}`;
+		logger.error({
+			status: response.status,
+			error: errorMessage
+		}, "Failed to delete project via API");
+		throw new Error(errorMessage);
+	}
+	logger.info({ projectId }, "Successfully deleted project via API");
+}
+function parseError(errorText) {
+	let result;
+	try {
+		const errorJson = JSON.parse(errorText);
+		if (errorJson.error) {
+			const { error } = errorJson;
+			result = error?.message ?? error;
+		}
+	} catch {
+		if (errorText) result = errorText;
+	}
+	return result;
+}
+
+//#endregion
+export { createFullProjectViaAPI, deleteFullProjectViaAPI, getFullProjectViaAPI, parseError, updateFullProjectViaAPI };

package/dist/runner.d.ts

@@ -0,0 +1,41 @@
+import { AgentInterface, GenerateOptions, MessageInput, RunResult, StreamResponse } from "./types.js";
+
+//#region src/runner.d.ts
+declare class Runner {
+  /**
+   * Run an agent until completion, handling transfers and tool calls
+   * Similar to OpenAI's Runner.run() pattern
+   * NOTE: This now requires an agent instead of an agent
+   */
+  static run(agent: AgentInterface, messages: MessageInput, options?: GenerateOptions): Promise<RunResult>;
+  /**
+   * Stream an agent's response
+   */
+  static stream(agent: AgentInterface, messages: MessageInput, options?: GenerateOptions): Promise<StreamResponse>;
+  /**
+   * Execute multiple agent in parallel and return the first successful result
+   */
+  static raceAgents(agent: AgentInterface[], messages: MessageInput, options?: GenerateOptions): Promise<RunResult>;
+  private static normalizeToMessageHistory;
+  /**
+   * Validate agent configuration before running
+   */
+  static validateAgent(agent: AgentInterface): {
+    valid: boolean;
+    errors: string[];
+  };
+  /**
+   * Get execution statistics for an agent
+   */
+  static getExecutionStats(agent: AgentInterface, messages: MessageInput, options?: GenerateOptions): Promise<{
+    estimatedTurns: number;
+    estimatedTokens: number;
+    subAgentCount: number;
+    defaultSubAgent: string | undefined;
+  }>;
+}
+declare const run: typeof Runner.run;
+declare const stream: typeof Runner.stream;
+declare const raceAgents: typeof Runner.raceAgents;
+//#endregion
+export { Runner, raceAgents, run, stream };

package/dist/runner.js

@@ -0,0 +1,145 @@
+import { MaxTurnsExceededError } from "./types.js";
+import { getLogger } from "@inkeep/agents-core";
+
+//#region src/runner.ts
+const logger = getLogger("runner");
+var Runner = class Runner {
+	/**
+	* Run an agent until completion, handling transfers and tool calls
+	* Similar to OpenAI's Runner.run() pattern
+	* NOTE: This now requires an agent instead of an agent
+	*/
+	static async run(agent, messages, options) {
+		const maxTurns = options?.maxTurns || 10;
+		let turnCount = 0;
+		const messageHistory = Runner.normalizeToMessageHistory(messages);
+		const allToolCalls = [];
+		logger.info({
+			agentId: agent.getId(),
+			defaultSubAgent: agent.getDefaultSubAgent()?.getName(),
+			maxTurns,
+			initialMessageCount: messageHistory.length
+		}, "Starting agent run");
+		while (turnCount < maxTurns) {
+			logger.debug({
+				agentId: agent.getId(),
+				turnCount,
+				messageHistoryLength: messageHistory.length
+			}, "Starting turn");
+			const response = await agent.generate(messageHistory, options);
+			turnCount++;
+			logger.info({
+				agentId: agent.getId(),
+				turnCount,
+				responseLength: response.length
+			}, "Agent generation completed");
+			return {
+				finalOutput: response,
+				agent: agent.getDefaultSubAgent() || {},
+				turnCount,
+				usage: {
+					inputTokens: 0,
+					outputTokens: 0
+				},
+				metadata: {
+					toolCalls: allToolCalls,
+					transfers: []
+				}
+			};
+		}
+		logger.error({
+			agentId: agent.getId(),
+			maxTurns,
+			finalTurnCount: turnCount
+		}, "Maximum turns exceeded");
+		throw new MaxTurnsExceededError(maxTurns);
+	}
+	/**
+	* Stream an agent's response
+	*/
+	static async stream(agent, messages, options) {
+		logger.info({
+			agentId: agent.getId(),
+			defaultSubAgent: agent.getDefaultSubAgent()?.getName()
+		}, "Starting agent stream");
+		return agent.stream(messages, options);
+	}
+	/**
+	* Execute multiple agent in parallel and return the first successful result
+	*/
+	static async raceAgents(agent, messages, options) {
+		if (agent.length === 0) throw new Error("No agent provided for race");
+		logger.info({
+			agentCount: agent.length,
+			agentIds: agent.map((g) => g.getId())
+		}, "Starting agent race");
+		const promises = agent.map(async (agent$1, index) => {
+			try {
+				return {
+					...await Runner.run(agent$1, messages, options),
+					raceIndex: index
+				};
+			} catch (error) {
+				logger.error({
+					agentId: agent$1.getId(),
+					error: error instanceof Error ? error.message : "Unknown error"
+				}, "Agent failed in race");
+				throw error;
+			}
+		});
+		const result = await Promise.race(promises);
+		logger.info({
+			winningAgentId: result.agentId || "unknown",
+			raceIndex: result.raceIndex
+		}, "Agent race completed");
+		return result;
+	}
+	static normalizeToMessageHistory(messages) {
+		if (typeof messages === "string") return [{
+			role: "user",
+			content: messages
+		}];
+		if (Array.isArray(messages)) return messages.map((msg) => typeof msg === "string" ? {
+			role: "user",
+			content: msg
+		} : msg);
+		return [messages];
+	}
+	/**
+	* Validate agent configuration before running
+	*/
+	static validateAgent(agent) {
+		const errors = [];
+		if (!agent.getId()) errors.push("Agent ID is required");
+		const defaultSubAgent = agent.getDefaultSubAgent();
+		if (!defaultSubAgent) errors.push("Default agent is required");
+		else if (!defaultSubAgent.getName()) errors.push("Default agent name is required");
+		const subAgents = agent.getSubAgents();
+		if (subAgents.length === 0) errors.push("Agent must contain at least one subagent");
+		for (const subAgent of subAgents) if (!subAgent.getName()) errors.push(`Agent missing name`);
+		return {
+			valid: errors.length === 0,
+			errors
+		};
+	}
+	/**
+	* Get execution statistics for an agent
+	*/
+	static async getExecutionStats(agent, messages, options) {
+		const subAgents = agent.getSubAgents();
+		const defaultSubAgent = agent.getDefaultSubAgent();
+		const messageCount = Array.isArray(messages) ? messages.length : 1;
+		return {
+			estimatedTurns: Math.min(Math.max(messageCount, 1), options?.maxTurns || 10),
+			estimatedTokens: messageCount * 100,
+			subAgentCount: subAgents.length,
+			defaultSubAgent: defaultSubAgent?.getName()
+		};
+	}
+};
+const run = Runner.run.bind(Runner);
+const stream = Runner.stream.bind(Runner);
+const raceAgents = Runner.raceAgents.bind(Runner);
+
+//#endregion
+export { Runner, raceAgents, run, stream };

package/dist/status-component.d.ts

@@ -0,0 +1,22 @@
+import { StatusComponent as StatusComponent$1 } from "@inkeep/agents-core";
+import { z } from "zod";
+
+//#region src/status-component.d.ts
+type StatusComponentConfigWithZod = Omit<StatusComponent$1, 'detailsSchema'> & {
+  detailsSchema?: Record<string, unknown> | z.ZodObject<any>;
+};
+interface StatusComponentInterface {
+  config: StatusComponent$1;
+  getType(): string;
+  getDescription(): string | undefined;
+  getDetailsSchema(): StatusComponent$1['detailsSchema'];
+}
+declare class StatusComponent implements StatusComponentInterface {
+  config: StatusComponent$1;
+  constructor(config: StatusComponentConfigWithZod);
+  getType(): string;
+  getDescription(): string | undefined;
+  getDetailsSchema(): StatusComponent$1['detailsSchema'];
+}
+//#endregion
+export { StatusComponent, StatusComponentInterface };

package/dist/status-component.js

@@ -0,0 +1,36 @@
+import { getLogger } from "@inkeep/agents-core";
+import { convertZodToJsonSchema, isZodSchema } from "@inkeep/agents-core/utils/schema-conversion";
+
+//#region src/status-component.ts
+const logger = getLogger("statusComponent");
+var StatusComponent = class {
+	config;
+	constructor(config) {
+		let processedDetailsSchema;
+		if (config.detailsSchema && isZodSchema(config.detailsSchema)) {
+			const jsonSchema = convertZodToJsonSchema(config.detailsSchema);
+			processedDetailsSchema = {
+				type: "object",
+				properties: jsonSchema.properties || {},
+				required: jsonSchema.required || void 0
+			};
+		} else processedDetailsSchema = config.detailsSchema;
+		this.config = {
+			...config,
+			detailsSchema: processedDetailsSchema
+		};
+		logger.info({ statusComponentType: config.type }, "StatusComponent constructor initialized");
+	}
+	getType() {
+		return this.config.type;
+	}
+	getDescription() {
+		return this.config.description;
+	}
+	getDetailsSchema() {
+		return this.config.detailsSchema;
+	}
+};
+
+//#endregion
+export { StatusComponent };

package/dist/subAgent.d.ts

@@ -0,0 +1,52 @@
+import { Tool } from "./tool.js";
+import { AgentTool, AllDelegateInputInterface, AllDelegateOutputInterface, SubAgentConfig, SubAgentInterface, subAgentExternalAgentInterface, subAgentTeamAgentInterface } from "./types.js";
+import { ArtifactComponentApiInsert, DataComponentApiInsert } from "@inkeep/agents-core";
+
+//#region src/subAgent.d.ts
+declare class SubAgent implements SubAgentInterface {
+  config: SubAgentConfig;
+  readonly type: "internal";
+  private baseURL;
+  private tenantId;
+  private projectId;
+  private initialized;
+  constructor(config: SubAgentConfig);
+  setContext(tenantId: string, projectId: string, baseURL?: string): void;
+  getId(): string;
+  getName(): string;
+  getInstructions(): string;
+  /**
+   * Get the agent's description (the human-readable description field)
+   */
+  getDescription(): string;
+  getTools(): Record<string, AgentTool>;
+  getModels(): typeof this.config.models;
+  setModels(models: typeof this.config.models): void;
+  getTransfers(): SubAgentInterface[];
+  getSubAgentDelegates(): SubAgentInterface[];
+  getExternalAgentDelegates(): subAgentExternalAgentInterface[];
+  getTeamAgentDelegates(): subAgentTeamAgentInterface[];
+  getDelegates(): AllDelegateOutputInterface[];
+  getDataComponents(): DataComponentApiInsert[];
+  getArtifactComponents(): ArtifactComponentApiInsert[];
+  addTool(_name: string, tool: Tool): void;
+  addTransfer(...agents: SubAgentInterface[]): void;
+  addDelegate(...agents: AllDelegateInputInterface[]): void;
+  init(): Promise<void>;
+  private upsertAgent;
+  private saveToolsAndRelations;
+  private saveDataComponents;
+  private saveArtifactComponents;
+  private loadDataComponents;
+  private loadArtifactComponents;
+  private createFunctionTool;
+  private createTool;
+  private createDataComponent;
+  private createArtifactComponent;
+  private createAgentDataComponentRelation;
+  private createAgentArtifactComponentRelation;
+  private createAgentToolRelation;
+}
+declare function agent(config: SubAgentConfig): SubAgent;
+//#endregion
+export { SubAgent, agent };