@anvia/core 1.0.0-rc.1 → 1.0.0-rc.3

package/dist/interactions-csssHYcN.d.ts

@@ -0,0 +1,174 @@
+import { e as CompletionRequest, f as CompletionResponse, o as JsonValue, x as ToolResultContentPart, J as JsonObject, _ as ToolQuestionAnswer } from './types-D9rKQ_as.js';
+import { M as MaybePromise } from './type-utils-CtHVDRn_.js';
+import { z } from 'zod';
+
+type CompletionRequestMiddlewareArgs = {
+    turn: number;
+    request: CompletionRequest;
+    originalRequest: CompletionRequest;
+};
+type CompletionRequestMiddlewareResult = {
+    request: CompletionRequest;
+} | undefined;
+type CompletionResponseMiddlewareArgs<RawResponse = unknown> = {
+    turn: number;
+    request: CompletionRequest;
+    response: CompletionResponse<RawResponse>;
+    originalResponse: CompletionResponse<RawResponse>;
+};
+type CompletionResponseMiddlewareResult<RawResponse = unknown> = {
+    response: CompletionResponse<RawResponse>;
+} | undefined;
+type ToolInputMiddlewareArgs = {
+    toolName: string;
+    args: string;
+    originalArgs: string;
+    turn: number;
+    toolCallId?: string | undefined;
+    internalCallId: string;
+};
+type ToolInputMiddlewareResult = {
+    args: JsonValue | string;
+} | undefined;
+type ToolResultMiddlewareArgs = {
+    toolName: string;
+    args: string;
+    result: string;
+    originalResult: string;
+    structuredResult?: readonly ToolResultContentPart[] | undefined;
+    originalStructuredResult?: readonly ToolResultContentPart[] | undefined;
+    turn: number;
+    toolCallId?: string | undefined;
+    internalCallId: string;
+};
+type ToolOutputMiddlewareArgs = ToolResultMiddlewareArgs;
+type ToolOutputMiddlewareResult = string | {
+    result?: string | undefined;
+    structuredResult?: readonly ToolResultContentPart[] | undefined;
+} | undefined;
+interface AgentMiddleware<RawResponse = unknown> {
+    onCompletionRequest?(args: CompletionRequestMiddlewareArgs): MaybePromise<CompletionRequestMiddlewareResult>;
+    onCompletionResponse?(args: CompletionResponseMiddlewareArgs<RawResponse>): MaybePromise<CompletionResponseMiddlewareResult<RawResponse>>;
+    onToolInput?(args: ToolInputMiddlewareArgs): MaybePromise<ToolInputMiddlewareResult>;
+    onToolOutput?(args: ToolOutputMiddlewareArgs): MaybePromise<ToolOutputMiddlewareResult>;
+}
+declare function createMiddleware<RawResponse = unknown>(middleware: AgentMiddleware<RawResponse>): AgentMiddleware<RawResponse>;
+
+type AgentQuestionChoice = Readonly<{
+    label: string;
+    value: string;
+}>;
+type AgentQuestionPrompt = Readonly<{
+    id: string;
+    text: string;
+    choices?: readonly AgentQuestionChoice[];
+    allowCustom?: boolean;
+}>;
+type AgentQuestionAnswer = ToolQuestionAnswer;
+type AgentInteractionRequestBase = Readonly<{
+    id: string;
+    toolName: string;
+    toolCallId: string;
+    callId?: string;
+    internalCallId: string;
+}>;
+type AgentToolApprovalRequest = AgentInteractionRequestBase & Readonly<{
+    type: "tool-approval";
+    input: JsonValue;
+    reason?: string;
+}>;
+type AgentToolQuestionRequest = AgentInteractionRequestBase & Readonly<{
+    type: "tool-question";
+    questions: readonly AgentQuestionPrompt[];
+}>;
+type AgentInteractionRequest = AgentToolApprovalRequest | AgentToolQuestionRequest;
+type AgentInteractionResponse = Readonly<{
+    type: "tool-approval";
+    approved: boolean;
+    reason?: string;
+}> | Readonly<{
+    type: "tool-question";
+    answers: readonly AgentQuestionAnswer[];
+}>;
+type AgentContinuation = Readonly<{
+    version: 1;
+    agentId: string;
+    sourceRunId: string;
+    interaction: AgentInteractionRequest;
+    state: JsonObject;
+}>;
+declare const agentInteractionRequestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    input: z.ZodCustom<JsonValue, JsonValue>;
+    reason: z.ZodOptional<z.ZodString>;
+    id: z.ZodString;
+    toolName: z.ZodString;
+    toolCallId: z.ZodString;
+    callId: z.ZodOptional<z.ZodString>;
+    internalCallId: z.ZodString;
+    type: z.ZodLiteral<"tool-approval">;
+}, z.core.$strict>, z.ZodObject<{
+    questions: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        text: z.ZodString;
+        choices: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            value: z.ZodString;
+        }, z.core.$strict>>>;
+        allowCustom: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>;
+    id: z.ZodString;
+    toolName: z.ZodString;
+    toolCallId: z.ZodString;
+    callId: z.ZodOptional<z.ZodString>;
+    internalCallId: z.ZodString;
+    type: z.ZodLiteral<"tool-question">;
+}, z.core.$strict>], "type">;
+declare const agentInteractionResponseSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"tool-approval">;
+    approved: z.ZodBoolean;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"tool-question">;
+    answers: z.ZodArray<z.ZodObject<{
+        questionId: z.ZodString;
+        value: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>], "type">;
+declare const agentContinuationSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    agentId: z.ZodString;
+    sourceRunId: z.ZodString;
+    interaction: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        input: z.ZodCustom<JsonValue, JsonValue>;
+        reason: z.ZodOptional<z.ZodString>;
+        id: z.ZodString;
+        toolName: z.ZodString;
+        toolCallId: z.ZodString;
+        callId: z.ZodOptional<z.ZodString>;
+        internalCallId: z.ZodString;
+        type: z.ZodLiteral<"tool-approval">;
+    }, z.core.$strict>, z.ZodObject<{
+        questions: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            text: z.ZodString;
+            choices: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                label: z.ZodString;
+                value: z.ZodString;
+            }, z.core.$strict>>>;
+            allowCustom: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>>;
+        id: z.ZodString;
+        toolName: z.ZodString;
+        toolCallId: z.ZodString;
+        callId: z.ZodOptional<z.ZodString>;
+        internalCallId: z.ZodString;
+        type: z.ZodLiteral<"tool-question">;
+    }, z.core.$strict>], "type">;
+    state: z.ZodCustom<JsonObject, JsonObject>;
+}, z.core.$strict>;
+declare function parseAgentInteractionRequest(value: unknown): AgentInteractionRequest;
+declare function parseAgentInteractionResponse(value: unknown): AgentInteractionResponse;
+declare function parseAgentContinuation(value: unknown): AgentContinuation;
+declare function assertAgentInteractionResponse(request: AgentInteractionRequest, response: AgentInteractionResponse): void;
+
+export { type AgentContinuation as A, type CompletionRequestMiddlewareArgs as C, type ToolInputMiddlewareArgs as T, type AgentInteractionRequest as a, type AgentInteractionResponse as b, type AgentMiddleware as c, type AgentQuestionAnswer as d, type AgentQuestionChoice as e, type AgentQuestionPrompt as f, type AgentToolApprovalRequest as g, type AgentToolQuestionRequest as h, type CompletionRequestMiddlewareResult as i, type CompletionResponseMiddlewareArgs as j, type CompletionResponseMiddlewareResult as k, type ToolInputMiddlewareResult as l, type ToolOutputMiddlewareArgs as m, type ToolOutputMiddlewareResult as n, type ToolResultMiddlewareArgs as o, agentContinuationSchema as p, agentInteractionRequestSchema as q, agentInteractionResponseSchema as r, createMiddleware as s, parseAgentContinuation as t, parseAgentInteractionRequest as u, parseAgentInteractionResponse as v, assertAgentInteractionResponse as w };

package/dist/internal/agent.d.ts

@@ -1,24 +1,31 @@
-export { A as Agent, R as ResolvedAgentOptions, k as createResolvedAgent, l as getResolvedAgentOptions } from '../agent-DGYY_onS.js';
-import { P as ProviderTool, M as Message, U as Usage, g as CompletionResponse, u as ToolResultContent } from '../types-B3A4YxaA.js';
-import { T as ToolIndex } from '../dynamic-tools-i9woysFa.js';
-import { A as AnyTool, a as ToolApprovalContext } from '../tool-C_8GudXn.js';
-import { v as AgentToolApprovalRequest, n as AgentRunOptions } from '../index-DxB74ybJ.js';
-import '../guardrails/index.js';
-import '../type-utils-CtHVDRn_.js';
-import '../types-BBEGKB9m.js';
-import '../middleware-KynLg_RW.js';
+import { R as ResolvedAgentOptions, A as Agent } from '../agent-CXScUOpX.js';
+import { C as CompletionModel, P as ProviderTool, M as Message, U as Usage, f as CompletionResponse, x as ToolResultContentPart } from '../types-D9rKQ_as.js';
+import { T as ToolIndex } from '../dynamic-tools-AEBOTgu1.js';
+import { A as AnyTool } from '../tool-r62gf3QY.js';
+import { e as MemoryCompactionInfo } from '../types-DbolvLtZ.js';
+import '../retry-CjvSlKGW.js';
 import '../zod-schema-C7F4clpm.js';
 import 'zod';
-import '../types-DulRCYdB.js';
-import '@modelcontextprotocol/sdk/client/sse.js';
-import '@modelcontextprotocol/sdk/client/stdio.js';
+import '../types-CIPaIbZo.js';
+import '../type-utils-CtHVDRn_.js';
+import '../client-DvUatElp.js';
+import 'node:child_process';
+import 'node:stream';
+import '@modelcontextprotocol/sdk/client/auth.js';
 import '@modelcontextprotocol/sdk/client/streamableHttp.js';
-import '../types-DhQfwiZn.js';
-import '../types-DT3nEemY.js';
-import '../types-p55Jc-sr.js';
-import '../retry-D3Ruy-ba.js';
+import '@modelcontextprotocol/sdk/shared/transport.js';
+import '../types-CElwurHZ.js';
+import '../interactions-csssHYcN.js';
+import '../types-RT3cuyRk.js';
+import '../types-Cr4uiYo5.js';
+import '../model-call-options-CZkSw_xN.js';
+import '../types-C3gv9EX6.js';
+
+declare function createResolvedAgent<Output = string, M extends CompletionModel = CompletionModel, ContextDocument = unknown>(options: ResolvedAgentOptions<Output, M, ContextDocument>): Agent<Output, M, ContextDocument>;
+declare function getResolvedAgentOptions<Output, M extends CompletionModel, ContextDocument>(agent: Agent<Output, M, ContextDocument>): ResolvedAgentOptions<Output, M, ContextDocument>;
 
 type AgentToolState = {
+    configuredTools: readonly AnyTool[];
     staticTools: readonly AnyTool[];
     providerTools: readonly ProviderTool[];
     toolIndexes: readonly ToolIndex[];
@@ -70,7 +77,9 @@ type RunStartHookArgs = {
     run: RunControl;
 };
 type RunEndHookArgs = {
-    output: string;
+    status: "completed";
+    output: unknown;
+    text: string;
     usage: Usage;
     messages: Message[];
     run: RunControl;
@@ -104,7 +113,8 @@ type CompletionErrorHookArgs = {
 };
 type ToolHookArgs = {
     toolName: string;
-    toolCallId?: string;
+    toolCallId: string;
+    callId?: string;
     internalCallId: string;
     args: string;
 };
@@ -113,7 +123,7 @@ type ToolCallHookArgs = ToolHookArgs & {
 };
 type ToolResultHookArgs = ToolHookArgs & {
     result: string;
-    structuredResult?: ToolResultContent[] | undefined;
+    structuredResult?: readonly ToolResultContentPart[] | undefined;
     run: RunControl;
 };
 type ToolErrorHookArgs = ToolHookArgs & {
@@ -136,18 +146,15 @@ interface AgentHook<RawResponse = unknown> {
 
 declare function createHook<RawResponse = unknown>(hook: AgentHook<RawResponse>): AgentHook<RawResponse>;
 
-type ToolApprovalRequest<Args = unknown> = ToolApprovalContext<Args> & {
-    id: string;
-    reason?: string | undefined;
-    rejectMessage?: string | undefined;
-};
-
-declare function getAgentApprovalRequestDetails(approval: AgentToolApprovalRequest): ToolApprovalRequest | undefined;
-
 type InternalAgentRunOptions = {
     hook?: AgentHook | undefined;
+    onFailure?: ((failure: {
+        error: unknown;
+        messages: readonly Message[];
+    }) => void) | undefined;
+    onMemoryCompaction?: ((compaction: MemoryCompactionInfo) => void | Promise<void>) | undefined;
     runId?: string | undefined;
 };
-declare function withInternalAgentRunOptions<T extends AgentRunOptions>(options: T, internal: InternalAgentRunOptions): T;
+declare function withInternalAgentRunOptions<T extends object>(options: T, internal: InternalAgentRunOptions): T;
 
-export { type AgentHook, type InternalAgentRunOptions, createHook, getAgentApprovalRequestDetails, getAgentToolState, withInternalAgentRunOptions };
+export { Agent, type AgentHook, type InternalAgentRunOptions, ResolvedAgentOptions, createHook, createResolvedAgent, getAgentToolState, getResolvedAgentOptions, withInternalAgentRunOptions };

package/dist/internal/agent.js

@@ -1,28 +1,61 @@
 import {
   Agent,
   createHook,
-  createResolvedAgent,
-  getAgentApprovalRequestDetails,
   getAgentToolState,
-  getResolvedAgentOptions,
+  markResolvedAgentOptions,
   withInternalAgentRunOptions
-} from "../chunk-IL3ZSNJI.js";
+} from "../chunk-BY4OMNIU.js";
 import "../chunk-YK4WAAS4.js";
-import "../chunk-6WGGTJE6.js";
-import "../chunk-R2LJSQUW.js";
-import "../chunk-5XKDW36Z.js";
-import "../chunk-DZ3CKYTH.js";
-import "../chunk-I6G7BC42.js";
-import "../chunk-M3IOWB4Y.js";
-import "../chunk-RFDVKCIE.js";
-import "../chunk-ADH7NNCS.js";
-import "../chunk-A3UBYTJT.js";
-import "../chunk-FNQB2JEH.js";
+import "../chunk-5MK3BISB.js";
+import "../chunk-CQNNSZPG.js";
+import "../chunk-KV6QCRQ4.js";
+import "../chunk-3CMWKK32.js";
+import "../chunk-KFR4CDGK.js";
+import "../chunk-VKYZZXP5.js";
+import "../chunk-TRQ3XRFD.js";
+import "../chunk-GQL5KRAH.js";
+import "../chunk-3RM57ZT2.js";
+import "../chunk-MGNTXGTX.js";
+import "../chunk-D2ECOWN5.js";
+import "../chunk-PK5LKOFL.js";
+import "../chunk-FN7HLLAZ.js";
+import "../chunk-AZB6N7P4.js";
+
+// src/agent/resolved-agent.ts
+function createResolvedAgent(options) {
+  return new Agent(markResolvedAgentOptions(options));
+}
+function getResolvedAgentOptions(agent) {
+  const toolState = getAgentToolState(agent);
+  return {
+    id: agent.id,
+    name: agent.name,
+    description: agent.description,
+    model: agent.model,
+    instructions: agent.instructions,
+    context: [...agent.context],
+    temperature: agent.temperature,
+    maxTokens: agent.maxTokens,
+    providerOptions: agent.providerOptions,
+    retries: agent.retries,
+    tools: [...toolState.configuredTools],
+    mcpServers: [...agent.mcpServers],
+    providerTools: [...toolState.providerTools],
+    toolIndexes: [...toolState.toolIndexes],
+    toolChoice: agent.toolChoice,
+    defaultMaxTurns: agent.defaultMaxTurns,
+    lifecycle: agent.lifecycle,
+    outputSchema: agent.outputSchema,
+    observability: agent.observability,
+    guardrails: [...agent.guardrails],
+    middlewares: [...agent.middlewares],
+    memory: agent.memory
+  };
+}
 export {
   Agent,
   createHook,
   createResolvedAgent,
-  getAgentApprovalRequestDetails,
   getAgentToolState,
   getResolvedAgentOptions,
   withInternalAgentRunOptions

package/dist/internal/agent.js.map

@@ -1 +1 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}
+{"version":3,"sources":["../../src/agent/resolved-agent.ts"],"sourcesContent":["import type { CompletionModel } from \"../completion\";\nimport { Agent } from \"./agent\";\nimport { markResolvedAgentOptions } from \"./resolve-options\";\nimport { getAgentToolState } from \"./tool-state\";\nimport type { ResolvedAgentOptions } from \"./types\";\n\nexport function createResolvedAgent<\n  Output = string,\n  M extends CompletionModel = CompletionModel,\n  ContextDocument = unknown,\n>(options: ResolvedAgentOptions<Output, M, ContextDocument>): Agent<Output, M, ContextDocument> {\n  return new Agent(markResolvedAgentOptions(options));\n}\n\nexport function getResolvedAgentOptions<Output, M extends CompletionModel, ContextDocument>(\n  agent: Agent<Output, M, ContextDocument>,\n): ResolvedAgentOptions<Output, M, ContextDocument> {\n  const toolState = getAgentToolState(agent);\n  return {\n    id: agent.id,\n    name: agent.name,\n    description: agent.description,\n    model: agent.model,\n    instructions: agent.instructions,\n    context: [...agent.context],\n    temperature: agent.temperature,\n    maxTokens: agent.maxTokens,\n    providerOptions: agent.providerOptions,\n    retries: agent.retries,\n    tools: [...toolState.configuredTools],\n    mcpServers: [...agent.mcpServers],\n    providerTools: [...toolState.providerTools],\n    toolIndexes: [...toolState.toolIndexes],\n    toolChoice: agent.toolChoice,\n    defaultMaxTurns: agent.defaultMaxTurns,\n    lifecycle: agent.lifecycle,\n    outputSchema: agent.outputSchema,\n    observability: agent.observability,\n    guardrails: [...agent.guardrails],\n    middlewares: [...agent.middlewares],\n    memory: agent.memory,\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAMO,SAAS,oBAId,SAA8F;AAC9F,SAAO,IAAI,MAAM,yBAAyB,OAAO,CAAC;AACpD;AAEO,SAAS,wBACd,OACkD;AAClD,QAAM,YAAY,kBAAkB,KAAK;AACzC,SAAO;AAAA,IACL,IAAI,MAAM;AAAA,IACV,MAAM,MAAM;AAAA,IACZ,aAAa,MAAM;AAAA,IACnB,OAAO,MAAM;AAAA,IACb,cAAc,MAAM;AAAA,IACpB,SAAS,CAAC,GAAG,MAAM,OAAO;AAAA,IAC1B,aAAa,MAAM;AAAA,IACnB,WAAW,MAAM;AAAA,IACjB,iBAAiB,MAAM;AAAA,IACvB,SAAS,MAAM;AAAA,IACf,OAAO,CAAC,GAAG,UAAU,eAAe;AAAA,IACpC,YAAY,CAAC,GAAG,MAAM,UAAU;AAAA,IAChC,eAAe,CAAC,GAAG,UAAU,aAAa;AAAA,IAC1C,aAAa,CAAC,GAAG,UAAU,WAAW;AAAA,IACtC,YAAY,MAAM;AAAA,IAClB,iBAAiB,MAAM;AAAA,IACvB,WAAW,MAAM;AAAA,IACjB,cAAc,MAAM;AAAA,IACpB,eAAe,MAAM;AAAA,IACrB,YAAY,CAAC,GAAG,MAAM,UAAU;AAAA,IAChC,aAAa,CAAC,GAAG,MAAM,WAAW;AAAA,IAClC,QAAQ,MAAM;AAAA,EAChB;AACF;","names":[]}

package/dist/mcp/index.d.ts

@@ -1,17 +1,23 @@
-import { M as McpConnection, a as McpServer, b as McpStdioOptions, c as McpHttpOptions, d as McpSseOptions } from '../types-DulRCYdB.js';
-export { e as McpClient, f as McpToolCallContent, g as McpToolCallResult, h as McpToolDefinition } from '../types-DulRCYdB.js';
-import '@modelcontextprotocol/sdk/client/sse.js';
-import '@modelcontextprotocol/sdk/client/stdio.js';
+import { M as McpClient, a as McpServer, b as McpClientGroupConnectOptions, c as McpTool } from '../client-DvUatElp.js';
+export { d as McpClientOptions, e as McpClientTransport, f as McpConnectOptions, g as McpCustomTransport, h as McpServerInfo, i as McpStdioTransport, j as McpStreamableHttpTransport, k as McpTransport } from '../client-DvUatElp.js';
+import 'node:child_process';
+import 'node:stream';
+import '@modelcontextprotocol/sdk/client/auth.js';
 import '@modelcontextprotocol/sdk/client/streamableHttp.js';
-import '../types-B3A4YxaA.js';
-import '../tool-C_8GudXn.js';
+import '@modelcontextprotocol/sdk/shared/transport.js';
+import '../types-D9rKQ_as.js';
+import '../model-call-options-CZkSw_xN.js';
+import '../tool-r62gf3QY.js';
 
-declare function connectMcp(connection: McpConnection): Promise<McpServer>;
+declare class McpClientGroup {
+    #private;
+    readonly clients: readonly McpClient[];
+    readonly servers: readonly McpServer[];
+    private constructor();
+    static connect(options: McpClientGroupConnectOptions): Promise<McpClientGroup>;
+    close(): Promise<void>;
+}
 
-declare const mcp: {
-    stdio(options: McpStdioOptions): McpConnection;
-    http(options: McpHttpOptions): McpConnection;
-    sse(options: McpSseOptions): McpConnection;
-};
+declare function isMcpTool(tool: unknown): tool is McpTool;
 
-export { McpConnection, McpHttpOptions, McpServer, McpSseOptions, McpStdioOptions, connectMcp, mcp };
+export { McpClient, McpClientGroup, McpClientGroupConnectOptions, McpServer, McpTool, isMcpTool };