@anvia/core 0.26.0 → 1.0.0-rc.10

package/dist/index.js

@@ -1,69 +1,80 @@
+import {
+  generateSpeech
+} from "./chunk-EFLT7XZD.js";
+import {
+  transcribe
+} from "./chunk-T2C3CGDQ.js";
+import {
+  generateImage
+} from "./chunk-I3Q7XSBB.js";
+import {
+  createMemoryScopeKey
+} from "./chunk-QOUPWOGW.js";
 import {
   SkillValidationError,
   loadSkills,
   skill
-} from "./chunk-NCPN4SJR.js";
-import {
-  coreMessagesToUIMessages,
-  uiMessagesToCoreMessages
-} from "./chunk-I6XOQ4LK.js";
-import "./chunk-CQNNSZPG.js";
-import "./chunk-XWUC7CIT.js";
+} from "./chunk-3SKZ2BKP.js";
 import {
-  AgentBuilder
-} from "./chunk-JI5YZWNT.js";
-import "./chunk-DALYP4PX.js";
+  Agent,
+  createVectorContext,
+  isVectorContext
+} from "./chunk-VX3HS6PE.js";
+import "./chunk-OJBFDBLG.js";
+import "./chunk-J6LVLV6P.js";
 import {
-  MaxTurnsError,
-  PromptCancelledError,
-  ToolApprovalRequiredError
-} from "./chunk-BALBBVI3.js";
+  MemoryCompactionConflictError,
+  MemoryCompactionError,
+  createSummaryMemoryCompactor,
+  isMemoryCompactionMessage
+} from "./chunk-5C6B6ZRH.js";
+import "./chunk-6BBOCFHV.js";
 import "./chunk-YK4WAAS4.js";
-import "./chunk-XUUY2L2D.js";
 import {
   createMiddleware,
+  createQuestionTool,
   createThinkTool
-} from "./chunk-HYUYZEAJ.js";
+} from "./chunk-SJMSS5SI.js";
 import {
   createTool
-} from "./chunk-MELYDKWQ.js";
+} from "./chunk-EMZKPRE6.js";
 import {
-  cancelPrompt,
-  createHook,
-  requestToolApproval,
-  runControl,
-  skipTool,
-  toolCallControl
-} from "./chunk-2ODTMRHP.js";
-import "./chunk-UQX6EXWG.js";
+  AgentRunBlockedError,
+  AgentRunCancelledError,
+  AgentStreamClosedError,
+  AgentStructuredOutputError,
+  AgentToolSuspensionError,
+  MaxTurnsError
+} from "./chunk-X4LK4ODN.js";
+import "./chunk-ZA564323.js";
+import "./chunk-3RM57ZT2.js";
+import "./chunk-D4PACGPA.js";
 import {
-  MemoryCompactionConflictError,
-  MemoryCompactionError,
-  createSummaryMemoryCompactor,
-  isMemoryCompactionSummary
-} from "./chunk-MRQLEK2B.js";
-import "./chunk-MNWK2USR.js";
-import "./chunk-OIMLU4SF.js";
-import "./chunk-Q25IWLBT.js";
-import {
-  createCompletion,
-  createCompletionStream,
-  createParsedCompletion
-} from "./chunk-MC3CCKEB.js";
-import {
-  AssistantContent,
-  Message,
-  ToolContent,
+  COMPLETION_PROVIDER_OUTPUT_ERROR_CODE,
+  CompletionProviderOutputError,
+  CompletionStructuredOutputError,
   Usage,
-  UserContent,
   calculateContextUsage,
+  generateCompletion,
   getAssistantGenerationMetadata,
-  isJsonValue,
   isProviderTool,
-  resolveCompletionModelInfo,
+  resolveModelContextLimits,
+  streamCompletion,
   withContextUsage
-} from "./chunk-ADH7NNCS.js";
-import "./chunk-WQKHFADH.js";
+} from "./chunk-7PHMK7W4.js";
+import "./chunk-7JLAIN6E.js";
+import {
+  createMessageSchema,
+  isMessage,
+  messageSchema,
+  messagesSchema,
+  parseMessage,
+  parseMessages
+} from "./chunk-QGX73TSQ.js";
+import {
+  isJsonValue
+} from "./chunk-3XQGVDU5.js";
+import "./chunk-3RWESPUG.js";
 import {
   allow,
   block,
@@ -71,49 +82,55 @@ import {
   defineInputGuardrail,
   defineOutputGuardrail,
   guardrails
-} from "./chunk-CWUJUSOS.js";
+} from "./chunk-AZB6N7P4.js";
 export {
-  AgentBuilder,
-  AssistantContent,
+  Agent,
+  AgentRunBlockedError,
+  AgentRunCancelledError,
+  AgentStreamClosedError,
+  AgentStructuredOutputError,
+  AgentToolSuspensionError,
+  COMPLETION_PROVIDER_OUTPUT_ERROR_CODE,
+  CompletionProviderOutputError,
+  CompletionStructuredOutputError,
   MaxTurnsError,
   MemoryCompactionConflictError,
   MemoryCompactionError,
-  Message,
-  PromptCancelledError,
   SkillValidationError,
-  ToolApprovalRequiredError,
-  ToolContent,
   Usage,
-  UserContent,
   allow,
   block,
   calculateContextUsage,
-  cancelPrompt,
-  coreMessagesToUIMessages,
-  createCompletion,
-  createCompletionStream,
-  createHook,
+  createMemoryScopeKey,
+  createMessageSchema,
   createMiddleware,
-  createParsedCompletion,
+  createQuestionTool,
   createSummaryMemoryCompactor,
   createThinkTool,
   createTool,
+  createVectorContext,
   defineGuardrailPolicy,
   defineInputGuardrail,
   defineOutputGuardrail,
+  generateCompletion,
+  generateImage,
+  generateSpeech,
   getAssistantGenerationMetadata,
   guardrails,
   isJsonValue,
-  isMemoryCompactionSummary,
+  isMemoryCompactionMessage,
+  isMessage,
   isProviderTool,
+  isVectorContext,
   loadSkills,
-  requestToolApproval,
-  resolveCompletionModelInfo,
-  runControl,
+  messageSchema,
+  messagesSchema,
+  parseMessage,
+  parseMessages,
+  resolveModelContextLimits,
   skill,
-  skipTool,
-  toolCallControl,
-  uiMessagesToCoreMessages,
+  streamCompletion,
+  transcribe,
   withContextUsage
 };
 //# sourceMappingURL=index.js.map

package/dist/internal/agent.d.ts

@@ -1,10 +1,156 @@
-export { A as Agent, e as AgentEventAppendInput, f as AgentEventRecord, c as AgentEventStore, g as AgentEventStoreInclude, d as AgentEventStoreOptions, j as AgentEventStoreRegistration, k as AgentOptions, h as AgentSession, i as AgentToolOptions, l as DEFAULT_MAX_TURNS, D as DynamicContextOptions, m as DynamicContextRegistration, b as DynamicToolOptions, n as DynamicToolRegistration } from '../agent-x3YTyv5i.js';
-import '../types-G12i56s2.js';
-import '../guardrails/index.js';
-import '../types-D9JpeAPF.js';
-import '../types-BrLbKnEz.js';
-import '../index-BxSbmOMr.js';
-import '../tool-Cohdv5GC.js';
-import '../middleware-Dp3d_pxi.js';
-import '../types-BCTRUGex.js';
-import '../types-O-abTIin.js';
+import { R as ResolvedAgentOptions, A as Agent } from '../agent-DWzW9SoH.js';
+import { c as CompletionModel, P as ProviderTool, M as Message, U as Usage, g as CompletionResponse, y as ToolResultContentPart } from '../types-DgvozfPc.js';
+import { T as ToolIndex } from '../dynamic-tools-aIZlg5x1.js';
+import { A as AnyTool } from '../tool-BpqpoRSE.js';
+import { e as MemoryCompactionInfo } from '../types-DKOXVTcq.js';
+import '../retry-CjvSlKGW.js';
+import '../zod-schema-C7F4clpm.js';
+import 'zod';
+import '../types-DhkodEft.js';
+import '../type-utils-CtHVDRn_.js';
+import '../types-DjqRHeAi.js';
+import '../types-Sue2hb_L.js';
+import '../agent/interactions/index.js';
+import '../middleware-kcF8AusP.js';
+import '../types-DC1U1XwW.js';
+import '../types-Cr4uiYo5.js';
+import '../model-call-options-CZkSw_xN.js';
+import '../types-CXNE592e.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[];
+};
+declare function getAgentToolState(agent: object): AgentToolState;
+
+type HookAction = {
+    type: "continue";
+} | {
+    type: "terminate";
+    reason: string;
+};
+type ToolApprovalRequestOptions = {
+    reason?: string;
+    rejectMessage?: string;
+};
+type ToolCallHookAction = {
+    type: "continue";
+} | {
+    type: "skip";
+    reason: string;
+} | {
+    type: "terminate";
+    reason: string;
+} | ({
+    type: "approval_request";
+} & ToolApprovalRequestOptions);
+type RunControl = {
+    continue(): HookAction;
+    cancel(reason: string): HookAction;
+};
+type ToolCallControl = {
+    run(): ToolCallHookAction;
+    skip(reason: string): ToolCallHookAction;
+    cancel(reason: string): ToolCallHookAction;
+    requestApproval(options?: ToolApprovalRequestOptions): ToolCallHookAction;
+};
+type HookCallback<Args> = (args: Args) => HookAction | Promise<HookAction | undefined> | Promise<void> | void;
+type ToolCallHookCallback<Args> = (args: Args) => ToolCallHookAction | Promise<ToolCallHookAction | undefined> | Promise<void> | void;
+type CompletionCallHookArgs = {
+    prompt: Message;
+    history: Message[];
+    run: RunControl;
+};
+type RunStartHookArgs = {
+    prompt: Message;
+    history: Message[];
+    maxTurns: number;
+    run: RunControl;
+};
+type RunEndHookArgs = {
+    status: "completed";
+    output: unknown;
+    text: string;
+    usage: Usage;
+    messages: Message[];
+    run: RunControl;
+};
+type RunErrorHookArgs = {
+    error: unknown;
+    usage: Usage;
+    messages: Message[];
+    run: RunControl;
+};
+type TurnStartHookArgs = {
+    turn: number;
+    prompt: Message;
+    history: Message[];
+    run: RunControl;
+};
+type TurnEndHookArgs<RawResponse = unknown> = {
+    turn: number;
+    response: CompletionResponse<RawResponse>;
+    run: RunControl;
+};
+type CompletionResponseHookArgs<RawResponse = unknown> = {
+    prompt: Message;
+    response: CompletionResponse<RawResponse>;
+    run: RunControl;
+};
+type CompletionErrorHookArgs = {
+    prompt: Message;
+    error: unknown;
+    run: RunControl;
+};
+type ToolHookArgs = {
+    toolName: string;
+    toolCallId: string;
+    callId?: string;
+    internalCallId: string;
+    args: string;
+};
+type ToolCallHookArgs = ToolHookArgs & {
+    tool: ToolCallControl;
+};
+type ToolResultHookArgs = ToolHookArgs & {
+    result: string;
+    structuredResult?: readonly ToolResultContentPart[] | undefined;
+    run: RunControl;
+};
+type ToolErrorHookArgs = ToolHookArgs & {
+    error: unknown;
+    run: RunControl;
+};
+interface AgentHook<RawResponse = unknown> {
+    onRunStart?: HookCallback<RunStartHookArgs>;
+    onRunEnd?: HookCallback<RunEndHookArgs>;
+    onRunError?: HookCallback<RunErrorHookArgs>;
+    onTurnStart?: HookCallback<TurnStartHookArgs>;
+    onTurnEnd?: HookCallback<TurnEndHookArgs<RawResponse>>;
+    onCompletionCall?: HookCallback<CompletionCallHookArgs>;
+    onCompletionResponse?: HookCallback<CompletionResponseHookArgs<RawResponse>>;
+    onCompletionError?: HookCallback<CompletionErrorHookArgs>;
+    onToolCall?: ToolCallHookCallback<ToolCallHookArgs>;
+    onToolResult?: HookCallback<ToolResultHookArgs>;
+    onToolError?: HookCallback<ToolErrorHookArgs>;
+}
+
+declare function createHook<RawResponse = unknown>(hook: AgentHook<RawResponse>): AgentHook<RawResponse>;
+
+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 object>(options: T, internal: InternalAgentRunOptions): T;
+
+export { Agent, type AgentHook, type InternalAgentRunOptions, ResolvedAgentOptions, createHook, createResolvedAgent, getAgentToolState, getResolvedAgentOptions, withInternalAgentRunOptions };

package/dist/internal/agent.js

@@ -1,25 +1,65 @@
 import {
   Agent,
-  AgentSession,
-  DEFAULT_MAX_TURNS
-} from "../chunk-DALYP4PX.js";
-import "../chunk-BALBBVI3.js";
+  createHook,
+  getAgentToolState,
+  markResolvedAgentOptions,
+  withInternalAgentRunOptions
+} from "../chunk-VX3HS6PE.js";
+import "../chunk-OJBFDBLG.js";
+import "../chunk-J6LVLV6P.js";
+import "../chunk-5C6B6ZRH.js";
+import "../chunk-6BBOCFHV.js";
 import "../chunk-YK4WAAS4.js";
-import "../chunk-XUUY2L2D.js";
-import "../chunk-HYUYZEAJ.js";
-import "../chunk-MELYDKWQ.js";
-import "../chunk-2ODTMRHP.js";
-import "../chunk-MRQLEK2B.js";
-import "../chunk-MNWK2USR.js";
-import "../chunk-OIMLU4SF.js";
-import "../chunk-Q25IWLBT.js";
-import "../chunk-MC3CCKEB.js";
-import "../chunk-ADH7NNCS.js";
-import "../chunk-WQKHFADH.js";
-import "../chunk-CWUJUSOS.js";
+import "../chunk-SJMSS5SI.js";
+import "../chunk-EMZKPRE6.js";
+import "../chunk-X4LK4ODN.js";
+import "../chunk-ZA564323.js";
+import "../chunk-3RM57ZT2.js";
+import "../chunk-D4PACGPA.js";
+import "../chunk-7PHMK7W4.js";
+import "../chunk-7JLAIN6E.js";
+import "../chunk-QGX73TSQ.js";
+import "../chunk-3XQGVDU5.js";
+import "../chunk-3RWESPUG.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,
-  AgentSession,
-  DEFAULT_MAX_TURNS
+  createHook,
+  createResolvedAgent,
+  getAgentToolState,
+  getResolvedAgentOptions,
+  withInternalAgentRunOptions
 };
 //# sourceMappingURL=agent.js.map

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,9 @@
-import { M as McpConnection, a as McpServer, b as McpStdioOptions, c as McpHttpOptions, d as McpSseOptions } from '../types-JJCxRnaZ.js';
-export { e as McpClient, f as McpToolCallContent, g as McpToolCallResult, h as McpToolDefinition } from '../types-JJCxRnaZ.js';
-import '@modelcontextprotocol/sdk/client/sse.js';
-import '@modelcontextprotocol/sdk/client/stdio.js';
-import '@modelcontextprotocol/sdk/client/streamableHttp.js';
-import '../types-G12i56s2.js';
-import '../tool-Cohdv5GC.js';
+import { M as McpTool } from '../types-DjqRHeAi.js';
+export { a as McpServer, b as McpServerInfo } from '../types-DjqRHeAi.js';
+import '../types-DgvozfPc.js';
+import '../model-call-options-CZkSw_xN.js';
+import '../tool-BpqpoRSE.js';
 
-declare function connectMcp(connection: McpConnection): Promise<McpServer>;
+declare function isMcpTool(tool: unknown): tool is McpTool;
 
-declare const mcp: {
-    stdio(options: McpStdioOptions): McpConnection;
-    http(options: McpHttpOptions): McpConnection;
-    sse(options: McpSseOptions): McpConnection;
-};
-
-export { McpConnection, McpHttpOptions, McpServer, McpSseOptions, McpStdioOptions, connectMcp, mcp };
+export { McpTool, isMcpTool };