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

package/dist/extractor/index.d.ts

@@ -1,5 +1,5 @@
 import { b as RetrySetting } from '../retry-CjvSlKGW.js';
-import { C as CompletionModel, J as JsonObject, U as Usage, g as CompletionResult } from '../types-CQ_ioXWK.js';
+import { C as CompletionModel, J as JsonObject, U as Usage, g as CompletionResult } from '../types-D9rKQ_as.js';
 import { Z as ZodSchema } from '../zod-schema-C7F4clpm.js';
 import '../model-call-options-CZkSw_xN.js';
 import 'zod';

package/dist/extractor/index.js

@@ -1,10 +1,10 @@
 import {
   ExtractionError,
   extract
-} from "../chunk-4WI3VGZK.js";
+} from "../chunk-ZCPOIDAQ.js";
 import "../chunk-MGNTXGTX.js";
-import "../chunk-KR3RCCHJ.js";
-import "../chunk-TIZYTPJO.js";
+import "../chunk-D2ECOWN5.js";
+import "../chunk-PK5LKOFL.js";
 import "../chunk-FN7HLLAZ.js";
 export {
   ExtractionError,

package/dist/guardrails/index.d.ts

@@ -1,134 +1,11 @@
-import { M as Message, J as JsonObject, U as Usage } from '../types-CQ_ioXWK.js';
-import { M as MaybePromise } from '../type-utils-CtHVDRn_.js';
+export { a as allow, f as appendGuardrailPolicies, b as block, d as defineGuardrailPolicy, c as defineInputGuardrail, e as defineOutputGuardrail, g as guardrails, h as hasEnforcedOutputGuardrails, n as normalizeGuardrailPolicies } from '../text-C_6eKrbC.js';
+import { c as GuardrailPolicy, g as InputGuardrailContext, j as InputGuardrailRunResult, i as OutputGuardrailContext, k as OutputGuardrailRunResult } from '../types-CIPaIbZo.js';
+export { l as GuardrailActionBase, m as GuardrailActionName, n as GuardrailAllow, o as GuardrailBlock, G as GuardrailBoundary, p as GuardrailCommonActions, a as GuardrailDecisionRecord, b as GuardrailMode, d as GuardrailPolicyInput, e as GuardrailPolicyOptions, q as GuardrailRunContext, I as InputGuardrail, f as InputGuardrailActions, r as InputGuardrailResult, s as InputGuardrailRewrite, O as OutputGuardrail, h as OutputGuardrailActions, t as OutputGuardrailResult, u as OutputGuardrailRewrite } from '../types-CIPaIbZo.js';
+import '../types-D9rKQ_as.js';
 import '../model-call-options-CZkSw_xN.js';
+import '../type-utils-CtHVDRn_.js';
 
-type GuardrailMode = "enforce" | "observe";
-type GuardrailBoundary = "input" | "output";
-type GuardrailRunContext = {
-    agentId: string;
-    runId: string;
-    sessionId?: string | undefined;
-    metadata?: JsonObject | undefined;
-};
-type GuardrailDecisionRecord = {
-    policyId: string;
-    guardrailId: string;
-    boundary: GuardrailBoundary;
-    mode: GuardrailMode;
-    action: GuardrailActionName;
-    applied: boolean;
-    reason?: string | undefined;
-    message?: string | undefined;
-    metadata?: JsonObject | undefined;
-    latencyMs: number;
-};
-type GuardrailActionName = "allow" | "block" | "rewrite" | "error";
-type GuardrailActionBase = {
-    reason?: string | undefined;
-    metadata?: JsonObject | undefined;
-};
-type GuardrailAllow = GuardrailActionBase & {
-    action: "allow";
-};
-type GuardrailBlock = GuardrailActionBase & {
-    action: "block";
-    reason: string;
-    message?: string | undefined;
-};
-type InputGuardrailRewrite = GuardrailActionBase & {
-    action: "rewrite";
-    prompt?: Message | undefined;
-    inputText?: string | undefined;
-};
-type OutputGuardrailRewrite = GuardrailActionBase & {
-    action: "rewrite";
-    outputText: string;
-};
-type InputGuardrailResult = GuardrailAllow | GuardrailBlock | InputGuardrailRewrite;
-type OutputGuardrailResult = GuardrailAllow | GuardrailBlock | OutputGuardrailRewrite;
-type GuardrailCommonActions = {
-    allow(options?: GuardrailActionBase): GuardrailAllow;
-    block(options: Omit<GuardrailBlock, "action">): GuardrailBlock;
-};
-type InputGuardrailActions = GuardrailCommonActions & {
-    rewrite(options: Omit<InputGuardrailRewrite, "action">): InputGuardrailRewrite;
-};
-type OutputGuardrailActions = GuardrailCommonActions & {
-    rewrite(options: Omit<OutputGuardrailRewrite, "action">): OutputGuardrailRewrite;
-};
-type InputGuardrailContext = {
-    prompt: Message;
-    history: Message[];
-    inputText: string;
-    run: GuardrailRunContext;
-};
-type OutputGuardrailContext = {
-    outputText: string;
-    messages: Message[];
-    usage: Usage;
-    run: GuardrailRunContext;
-};
-type InputGuardrail = {
-    id: string;
-    check(context: InputGuardrailContext, actions: InputGuardrailActions): MaybePromise<InputGuardrailResult | undefined>;
-};
-type OutputGuardrail = {
-    id: string;
-    check(context: OutputGuardrailContext, actions: OutputGuardrailActions): MaybePromise<OutputGuardrailResult | undefined>;
-};
-type GuardrailPolicy = {
-    id: string;
-    mode: GuardrailMode;
-    input: InputGuardrail[];
-    output: OutputGuardrail[];
-};
-type GuardrailPolicyOptions = {
-    id: string;
-    mode?: GuardrailMode | undefined;
-    input?: InputGuardrail[] | undefined;
-    output?: OutputGuardrail[] | undefined;
-};
-type GuardrailPolicyInput = GuardrailPolicy | GuardrailPolicy[];
-type InputGuardrailRunResult = {
-    prompt: Message;
-    inputText: string;
-    blocked: boolean;
-    message?: string | undefined;
-    decisions: GuardrailDecisionRecord[];
-};
-type OutputGuardrailRunResult = {
-    outputText: string;
-    blocked: boolean;
-    message?: string | undefined;
-    decisions: GuardrailDecisionRecord[];
-};
-declare function defineGuardrailPolicy(options: GuardrailPolicyOptions): GuardrailPolicy;
-declare function defineInputGuardrail(guardrail: InputGuardrail): InputGuardrail;
-declare function defineOutputGuardrail(guardrail: OutputGuardrail): OutputGuardrail;
-declare function allow(options?: GuardrailActionBase): GuardrailAllow;
-declare function block(options: Omit<GuardrailBlock, "action">): GuardrailBlock;
-declare const guardrails: {
-    blockText: typeof blockText;
-    redactText: typeof redactText;
-};
-declare function normalizeGuardrailPolicies(policies: GuardrailPolicyInput | undefined): GuardrailPolicy[];
-declare function appendGuardrailPolicies(current: GuardrailPolicy[], next: GuardrailPolicyInput): GuardrailPolicy[];
-declare function hasEnforcedOutputGuardrails(policies: GuardrailPolicy[]): boolean;
 declare function runInputGuardrails(policies: GuardrailPolicy[], context: InputGuardrailContext): Promise<InputGuardrailRunResult>;
 declare function runOutputGuardrails(policies: GuardrailPolicy[], context: OutputGuardrailContext): Promise<OutputGuardrailRunResult>;
-type TextPatternBoundary = "input" | "output";
-type TextPatternGuardrailFor<Boundary extends TextPatternBoundary> = Boundary extends "input" ? InputGuardrail : OutputGuardrail;
-type TextPatternGuardrailOptions<Boundary extends TextPatternBoundary = TextPatternBoundary> = {
-    id: string;
-    boundary: Boundary;
-    patterns: Array<string | RegExp>;
-    reason: string;
-    message?: string | undefined;
-};
-type TextPatternRedactOptions<Boundary extends TextPatternBoundary = TextPatternBoundary> = TextPatternGuardrailOptions<Boundary> & {
-    replacement?: string | undefined;
-};
-declare function blockText<Boundary extends TextPatternBoundary>(options: TextPatternGuardrailOptions<Boundary>): TextPatternGuardrailFor<Boundary>;
-declare function redactText<Boundary extends TextPatternBoundary>(options: TextPatternRedactOptions<Boundary>): TextPatternGuardrailFor<Boundary>;
 
-export { type GuardrailActionBase, type GuardrailActionName, type GuardrailAllow, type GuardrailBlock, type GuardrailBoundary, type GuardrailCommonActions, type GuardrailDecisionRecord, type GuardrailMode, type GuardrailPolicy, type GuardrailPolicyInput, type GuardrailPolicyOptions, type GuardrailRunContext, type InputGuardrail, type InputGuardrailActions, type InputGuardrailContext, type InputGuardrailResult, type InputGuardrailRewrite, type InputGuardrailRunResult, type OutputGuardrail, type OutputGuardrailActions, type OutputGuardrailContext, type OutputGuardrailResult, type OutputGuardrailRewrite, type OutputGuardrailRunResult, allow, appendGuardrailPolicies, block, defineGuardrailPolicy, defineInputGuardrail, defineOutputGuardrail, guardrails, hasEnforcedOutputGuardrails, normalizeGuardrailPolicies, runInputGuardrails, runOutputGuardrails };
+export { GuardrailPolicy, InputGuardrailContext, InputGuardrailRunResult, OutputGuardrailContext, OutputGuardrailRunResult, runInputGuardrails, runOutputGuardrails };

package/dist/guardrails/index.js

@@ -10,7 +10,7 @@ import {
   normalizeGuardrailPolicies,
   runInputGuardrails,
   runOutputGuardrails
-} from "../chunk-KIDGIJM7.js";
+} from "../chunk-AZB6N7P4.js";
 export {
   allow,
   appendGuardrailPolicies,

package/dist/image-generation/index.d.ts

@@ -1,7 +1,7 @@
 import { M as ModelCallOptions } from '../model-call-options-CZkSw_xN.js';
 import { b as RetrySetting } from '../retry-CjvSlKGW.js';
 export { R as RetryContext, a as RetryOptions } from '../retry-CjvSlKGW.js';
-import { J as JsonObject } from '../types-CQ_ioXWK.js';
+import { J as JsonObject } from '../types-D9rKQ_as.js';
 
 type ImageGenerationRequest = {
     prompt: string;

package/dist/index.d.ts

@@ -1,30 +1,31 @@
-export { A as Agent, a as AgentContextInput, b as AgentMemory, c as AgentMemoryOptions, d as AgentOptions, e as AgentToolInput, f as AgentToolOptions, C as CreateHybridVectorContextOptions, g as CreateVectorContextOptions, V as VectorContext, h as VectorContextBaseOptions, i as createVectorContext, j as isVectorContext } from './agent-yBG8e9Jj.js';
-export { AgentRunBlockedError, AgentRunCancelledError, MaxTurnsError } from './agent/index.js';
-export { A as AgentApprovalDecision, a as AgentApprovalRequiredEvent, b as AgentApprovalRequiredResult, c as AgentBlockedResult, d as AgentChildStreamEvent, e as AgentDeltaEvent, f as AgentErrorEvent, g as AgentErrorStreamEvent, h as AgentFinishEvent, i as AgentInput, j as AgentLifecycle, k as AgentMemoryCompactionEvent, l as AgentPrompt, m as AgentResponse, n as AgentResult, o as AgentRunOptions, p as AgentRunSettings, q as AgentStartEvent, r as AgentSteerInput, s as AgentStepFinishEvent, t as AgentStream, u as AgentStreamEvent, v as AgentToolApprovalRequest, w as AgentToolCallDeltaEvent, x as AgentToolFinishEvent, y as AgentToolStartEvent } from './types-3x3mOLHU.js';
+export { A as Agent, a as AgentContextInput, b as AgentMemory, c as AgentMemoryOptions, d as AgentOptions, e as AgentToolInput, f as AgentToolOptions, C as CreateHybridVectorContextOptions, g as CreateVectorContextOptions, V as VectorContext, h as VectorContextBaseOptions, i as createVectorContext, j as isVectorContext } from './agent-CXScUOpX.js';
+export { AgentRunBlockedError, AgentRunCancelledError, AgentStreamClosedError, AgentToolSuspensionError, MaxTurnsError } from './agent/index.js';
+export { A as AgentContinuation, a as AgentInteractionRequest, b as AgentInteractionResponse, c as AgentMiddleware, d as AgentQuestionAnswer, e as AgentQuestionChoice, f as AgentQuestionPrompt, g as AgentToolApprovalRequest, h as AgentToolQuestionRequest, C as CompletionRequestMiddlewareArgs, i as CompletionRequestMiddlewareResult, j as CompletionResponseMiddlewareArgs, k as CompletionResponseMiddlewareResult, T as ToolInputMiddlewareArgs, l as ToolInputMiddlewareResult, m as ToolOutputMiddlewareArgs, n as ToolOutputMiddlewareResult, o as ToolResultMiddlewareArgs, p as agentContinuationSchema, q as agentInteractionRequestSchema, r as agentInteractionResponseSchema, s as createMiddleware, t as parseAgentContinuation, u as parseAgentInteractionRequest, v as parseAgentInteractionResponse } from './interactions-csssHYcN.js';
+export { A as AgentBlockedResult, a as AgentChildStreamEvent, b as AgentDeltaEvent, c as AgentErrorEvent, d as AgentErrorStreamEvent, e as AgentFinishEvent, f as AgentInput, g as AgentLifecycle, h as AgentMemoryCompactionEvent, i as AgentPrompt, j as AgentResponse, k as AgentResult, l as AgentRunOptions, m as AgentRunSettings, n as AgentStartEvent, o as AgentSteerInput, p as AgentSteerReceipt, q as AgentStepFinishEvent, r as AgentStream, s as AgentStreamEvent, t as AgentSuspendedResult, u as AgentToolCallDeltaEvent, v as AgentToolFinishEvent, w as AgentToolStartEvent } from './types-CElwurHZ.js';
 export { M as ModelCallOptions } from './model-call-options-CZkSw_xN.js';
 export { R as RetryContext, a as RetryOptions, b as RetrySetting } from './retry-CjvSlKGW.js';
-export { A as AssistantContentPart, a as AssistantGenerationMetadata, b as AssistantMessage, C as CompletionModel, c as CompletionModelInfo, d as CompletionModelStreamEvent, e as CompletionRequest, f as CompletionResponse, g as CompletionResult, h as CompletionSource, i as CompletionStreamEvent, j as CompletionTool, k as ContextUsage, D as Document, F as FileData, l as FilePart, I as ImageDetail, m as ImagePart, J as JsonObject, n as JsonPrimitive, o as JsonValue, M as Message, p as ModelContextLimits, P as ProviderTool, q as ProviderToolCall, R as ReasoningContentType, r as ReasoningDetail, s as ReasoningPart, S as SystemMessage, T as TextPart, t as ToolCallPart, u as ToolChoice, v as ToolDefinition, w as ToolMessage, x as ToolResultContentPart, y as ToolResultOutput, z as ToolResultPart, U as Usage, B as UserContentPart, E as UserMessage, G as calculateContextUsage, H as getAssistantGenerationMetadata, K as isProviderTool, L as resolveModelContextLimits, N as withContextUsage } from './types-CQ_ioXWK.js';
-export { C as CompletionBaseOptions, a as CompletionInput, G as GenerateCompletionOptions, b as GenerateStructuredCompletionOptions, M as MessageMetadataSchema, S as StreamCompletionOptions, c as StreamStructuredCompletionOptions, d as createMessageSchema, g as generateCompletion, i as isJsonValue, e as isMessage, m as messageSchema, f as messagesSchema, p as parseMessage, h as parseMessages, s as streamCompletion } from './message-schema-Cn7ezRfJ.js';
-export { GuardrailBoundary, GuardrailDecisionRecord, GuardrailMode, GuardrailPolicy, GuardrailPolicyInput, GuardrailPolicyOptions, InputGuardrail, InputGuardrailActions, InputGuardrailContext, OutputGuardrail, OutputGuardrailActions, OutputGuardrailContext, allow, block, defineGuardrailPolicy, defineInputGuardrail, defineOutputGuardrail, guardrails } from './guardrails/index.js';
+export { A as AssistantContentPart, a as AssistantGenerationMetadata, b as AssistantMessage, C as CompletionModel, c as CompletionModelInfo, d as CompletionModelStreamEvent, e as CompletionRequest, f as CompletionResponse, g as CompletionResult, h as CompletionSource, i as CompletionStreamEvent, j as CompletionTool, k as ContextUsage, D as Document, F as FileData, l as FilePart, I as ImageDetail, m as ImagePart, J as JsonObject, n as JsonPrimitive, o as JsonValue, M as Message, p as ModelContextLimits, P as ProviderTool, q as ProviderToolCall, R as ReasoningContentType, r as ReasoningDetail, s as ReasoningPart, S as SystemMessage, T as TextPart, t as ToolCallPart, u as ToolChoice, v as ToolDefinition, w as ToolMessage, x as ToolResultContentPart, y as ToolResultOutput, z as ToolResultPart, U as Usage, B as UserContentPart, E as UserMessage, G as calculateContextUsage, H as getAssistantGenerationMetadata, K as isProviderTool, L as resolveModelContextLimits, N as withContextUsage } from './types-D9rKQ_as.js';
+export { C as CompletionBaseOptions, a as CompletionInput, G as GenerateCompletionOptions, b as GenerateStructuredCompletionOptions, M as MessageMetadataSchema, S as StreamCompletionOptions, c as StreamStructuredCompletionOptions, d as createMessageSchema, g as generateCompletion, i as isJsonValue, e as isMessage, m as messageSchema, f as messagesSchema, p as parseMessage, h as parseMessages, s as streamCompletion } from './message-schema-B2M7AYzR.js';
+export { a as allow, b as block, d as defineGuardrailPolicy, c as defineInputGuardrail, e as defineOutputGuardrail, g as guardrails } from './text-C_6eKrbC.js';
+export { G as GuardrailBoundary, a as GuardrailDecisionRecord, b as GuardrailMode, c as GuardrailPolicy, d as GuardrailPolicyInput, e as GuardrailPolicyOptions, I as InputGuardrail, f as InputGuardrailActions, g as InputGuardrailContext, O as OutputGuardrail, h as OutputGuardrailActions, i as OutputGuardrailContext } from './types-CIPaIbZo.js';
 export { GenerateImageOptions, GeneratedImage, ImageGenerationModel, ImageGenerationRequest, ImageGenerationResult, generateImage } from './image-generation/index.js';
 export { MemoryCompactionConflictError, MemoryCompactionError, createMemoryScopeKey, createSummaryMemoryCompactor, isMemoryCompactionMessage } from './memory/index.js';
-export { C as CreateMemoryScopeKeyOptions, a as CreateSummaryMemoryCompactorOptions, M as MemoryAppendOptions, b as MemoryClearOptions, c as MemoryCompactionCapability, d as MemoryCompactionConflictRetryOptions, e as MemoryCompactionInfo, f as MemoryCompactionMessage, g as MemoryCompactionMetadata, h as MemoryCompactionOptions, i as MemoryCompactionReplacePrefixOptions, j as MemoryCompactionReplacePrefixResult, k as MemoryCompactionSnapshot, l as MemoryCompactionSnapshotOptions, m as MemoryCompactor, n as MemoryCompactorInput, o as MemoryCompactorResult, p as MemoryConversation, q as MemoryConversationGetOptions, r as MemoryConversationListOptions, s as MemoryConversationMessage, t as MemoryConversationSummary, u as MemoryErrorOptions, v as MemoryInspector, w as MemoryLoadOptions, x as MemoryOptions, y as MemorySavePolicy, z as MemoryScope, A as MemoryScopeKeyOptions, B as MemoryScopeKeyResolver, D as MemoryStore } from './types-BVzM4RsC.js';
+export { C as CreateMemoryScopeKeyOptions, a as CreateSummaryMemoryCompactorOptions, M as MemoryAppendOptions, b as MemoryClearOptions, c as MemoryCompactionCapability, d as MemoryCompactionConflictRetryOptions, e as MemoryCompactionInfo, f as MemoryCompactionMessage, g as MemoryCompactionMetadata, h as MemoryCompactionOptions, i as MemoryCompactionReplacePrefixOptions, j as MemoryCompactionReplacePrefixResult, k as MemoryCompactionSnapshot, l as MemoryCompactionSnapshotOptions, m as MemoryCompactor, n as MemoryCompactorInput, o as MemoryCompactorResult, p as MemoryConversation, q as MemoryConversationGetOptions, r as MemoryConversationListOptions, s as MemoryConversationMessage, t as MemoryConversationSummary, u as MemoryErrorOptions, v as MemoryInspector, w as MemoryLoadOptions, x as MemoryOptions, y as MemorySavePolicy, z as MemoryScope, A as MemoryScopeKeyOptions, B as MemoryScopeKeyResolver, D as MemoryStore } from './types-DbolvLtZ.js';
 export { Z as ZodSchema } from './zod-schema-C7F4clpm.js';
 export { loadSkills, skill } from './skills/index.js';
-export { S as SkillValidationError } from './types-DiJqJejp.js';
+export { S as SkillValidationError } from './types-RT3cuyRk.js';
 export { GenerateSpeechOptions, SpeechGenerationModel, SpeechGenerationRequest, SpeechGenerationResult, generateSpeech } from './speech-generation/index.js';
-export { C as CreateToolOptions, c as createThinkTool, a as createTool } from './think-tool-6H2QNQzQ.js';
-export { A as AnyTool, T as Tool, a as ToolApprovalContext, b as ToolApprovalRequirement, c as ToolCallContext, d as ToolCallStreamEvent, e as ToolRequiresApproval } from './tool--Mz4v1eL.js';
-export { A as AgentMiddleware, C as CompletionRequestMiddlewareArgs, a as CompletionRequestMiddlewareResult, b as CompletionResponseMiddlewareArgs, c as CompletionResponseMiddlewareResult, T as ToolInputMiddlewareArgs, d as ToolInputMiddlewareResult, e as ToolOutputMiddlewareArgs, f as ToolOutputMiddlewareResult, g as ToolResultMiddlewareArgs, h as createMiddleware } from './middleware-C7PdmKF7.js';
+export { C as CreateToolOptions, c as createQuestionTool, a as createThinkTool, b as createTool } from './think-tool-D8frXxwV.js';
+export { A as AnyTool, T as Tool, a as ToolApprovalContext, b as ToolApprovalRequirement, c as ToolCallContext, d as ToolCallStreamEvent, e as ToolRequiresApproval } from './tool-r62gf3QY.js';
 export { TranscribeOptions, TranscriptionAudio, TranscriptionModel, TranscriptionRequest, TranscriptionResult, transcribe } from './transcription/index.js';
-import './client-B8DT1vUG.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 '@modelcontextprotocol/sdk/shared/transport.js';
-import './dynamic-tools-KwEGRbHp.js';
+import './dynamic-tools-AEBOTgu1.js';
 import './types-Cr4uiYo5.js';
-import './types-Dld1TpWj.js';
+import './types-C3gv9EX6.js';
 import './type-utils-CtHVDRn_.js';
 import 'zod';

package/dist/index.js

@@ -2,10 +2,13 @@ import {
   SkillValidationError,
   loadSkills,
   skill
-} from "./chunk-XKYYBABH.js";
+} from "./chunk-LXMAFD23.js";
 import {
   transcribe
 } from "./chunk-GKDERULJ.js";
+import {
+  generateImage
+} from "./chunk-BEYBU7VJ.js";
 import {
   createMemoryScopeKey
 } from "./chunk-QOUPWOGW.js";
@@ -14,30 +17,42 @@ import {
 } from "./chunk-AI5JMUW7.js";
 import {
   Agent,
-  AgentRunBlockedError,
-  AgentRunCancelledError,
-  MaxTurnsError,
+  agentContinuationSchema,
+  agentInteractionRequestSchema,
+  agentInteractionResponseSchema,
   createVectorContext,
-  isVectorContext
-} from "./chunk-DBSCKTUL.js";
+  isVectorContext,
+  parseAgentContinuation,
+  parseAgentInteractionRequest,
+  parseAgentInteractionResponse
+} from "./chunk-BY4OMNIU.js";
 import "./chunk-YK4WAAS4.js";
-import "./chunk-EINTGEGY.js";
+import "./chunk-5MK3BISB.js";
 import "./chunk-CQNNSZPG.js";
 import {
   createMiddleware,
+  createQuestionTool,
   createThinkTool
-} from "./chunk-D37WMSP6.js";
+} from "./chunk-KV6QCRQ4.js";
 import {
   createTool
-} from "./chunk-77AIYARB.js";
+} from "./chunk-3CMWKK32.js";
 import {
   MemoryCompactionConflictError,
   MemoryCompactionError,
   createSummaryMemoryCompactor,
   isMemoryCompactionMessage
-} from "./chunk-OJH6HWHX.js";
-import "./chunk-CWM7B2OO.js";
-import "./chunk-FMHLROPQ.js";
+} from "./chunk-KFR4CDGK.js";
+import "./chunk-VKYZZXP5.js";
+import {
+  AgentRunBlockedError,
+  AgentRunCancelledError,
+  AgentStreamClosedError,
+  AgentToolSuspensionError,
+  MaxTurnsError
+} from "./chunk-TRQ3XRFD.js";
+import "./chunk-GQL5KRAH.js";
+import "./chunk-3RM57ZT2.js";
 import "./chunk-MGNTXGTX.js";
 import {
   Usage,
@@ -48,7 +63,7 @@ import {
   resolveModelContextLimits,
   streamCompletion,
   withContextUsage
-} from "./chunk-KR3RCCHJ.js";
+} from "./chunk-D2ECOWN5.js";
 import {
   createMessageSchema,
   isJsonValue,
@@ -57,7 +72,8 @@ import {
   messagesSchema,
   parseMessage,
   parseMessages
-} from "./chunk-TIZYTPJO.js";
+} from "./chunk-PK5LKOFL.js";
+import "./chunk-FN7HLLAZ.js";
 import {
   allow,
   block,
@@ -65,26 +81,28 @@ import {
   defineInputGuardrail,
   defineOutputGuardrail,
   guardrails
-} from "./chunk-KIDGIJM7.js";
-import {
-  generateImage
-} from "./chunk-BEYBU7VJ.js";
-import "./chunk-FN7HLLAZ.js";
+} from "./chunk-AZB6N7P4.js";
 export {
   Agent,
   AgentRunBlockedError,
   AgentRunCancelledError,
+  AgentStreamClosedError,
+  AgentToolSuspensionError,
   MaxTurnsError,
   MemoryCompactionConflictError,
   MemoryCompactionError,
   SkillValidationError,
   Usage,
+  agentContinuationSchema,
+  agentInteractionRequestSchema,
+  agentInteractionResponseSchema,
   allow,
   block,
   calculateContextUsage,
   createMemoryScopeKey,
   createMessageSchema,
   createMiddleware,
+  createQuestionTool,
   createSummaryMemoryCompactor,
   createThinkTool,
   createTool,
@@ -105,6 +123,9 @@ export {
   loadSkills,
   messageSchema,
   messagesSchema,
+  parseAgentContinuation,
+  parseAgentInteractionRequest,
+  parseAgentInteractionResponse,
   parseMessage,
   parseMessages,
   resolveModelContextLimits,

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,25 +1,28 @@
-export { A as Agent, R as ResolvedAgentOptions, k as createResolvedAgent, l as getResolvedAgentOptions } from '../agent-yBG8e9Jj.js';
-import { P as ProviderTool, M as Message, U as Usage, f as CompletionResponse, x as ToolResultContentPart } from '../types-CQ_ioXWK.js';
-import { T as ToolIndex } from '../dynamic-tools-KwEGRbHp.js';
-import { A as AnyTool, a as ToolApprovalContext } from '../tool--Mz4v1eL.js';
-import { v as AgentToolApprovalRequest } from '../types-3x3mOLHU.js';
-import { e as MemoryCompactionInfo } from '../types-BVzM4RsC.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 '../guardrails/index.js';
+import '../types-CIPaIbZo.js';
 import '../type-utils-CtHVDRn_.js';
-import '../model-call-options-CZkSw_xN.js';
-import '../client-B8DT1vUG.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 '@modelcontextprotocol/sdk/shared/transport.js';
-import '../middleware-C7PdmKF7.js';
-import '../types-DiJqJejp.js';
+import '../types-CElwurHZ.js';
+import '../interactions-csssHYcN.js';
+import '../types-RT3cuyRk.js';
 import '../types-Cr4uiYo5.js';
-import '../types-Dld1TpWj.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[];
@@ -110,7 +113,8 @@ type CompletionErrorHookArgs = {
 };
 type ToolHookArgs = {
     toolName: string;
-    toolCallId?: string;
+    toolCallId: string;
+    callId?: string;
     internalCallId: string;
     args: string;
 };
@@ -142,14 +146,6 @@ 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: {
@@ -161,4 +157,4 @@ type InternalAgentRunOptions = {
 };
 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 };