@anvia/core 0.26.0 → 1.0.0-rc.2

package/dist/agent/index.js

@@ -1,23 +1,30 @@
 import {
-  AgentBuilder
-} from "../chunk-JI5YZWNT.js";
-import "../chunk-DALYP4PX.js";
-import "../chunk-BALBBVI3.js";
+  Agent,
+  AgentRunBlockedError,
+  AgentRunCancelledError,
+  MaxTurnsError,
+  createVectorContext,
+  isVectorContext
+} from "../chunk-DBSCKTUL.js";
 import "../chunk-YK4WAAS4.js";
-import "../chunk-XUUY2L2D.js";
-import "../chunk-HYUYZEAJ.js";
-import "../chunk-MELYDKWQ.js";
-import "../chunk-2ODTMRHP.js";
-import "../chunk-UQX6EXWG.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-EINTGEGY.js";
+import "../chunk-CQNNSZPG.js";
+import "../chunk-D37WMSP6.js";
+import "../chunk-77AIYARB.js";
+import "../chunk-OJH6HWHX.js";
+import "../chunk-CWM7B2OO.js";
+import "../chunk-FMHLROPQ.js";
+import "../chunk-MGNTXGTX.js";
+import "../chunk-KR3RCCHJ.js";
+import "../chunk-TIZYTPJO.js";
+import "../chunk-KIDGIJM7.js";
+import "../chunk-FN7HLLAZ.js";
 export {
-  AgentBuilder
+  Agent,
+  AgentRunBlockedError,
+  AgentRunCancelledError,
+  MaxTurnsError,
+  createVectorContext,
+  isVectorContext
 };
 //# sourceMappingURL=index.js.map

package/dist/agent-yBG8e9Jj.d.ts

@@ -0,0 +1,153 @@
+import { b as RetrySetting } from './retry-CjvSlKGW.js';
+import { D as Document, C as CompletionModel, P as ProviderTool, J as JsonObject, u as ToolChoice } from './types-CQ_ioXWK.js';
+import { Z as ZodSchema } from './zod-schema-C7F4clpm.js';
+import { GuardrailPolicyInput, GuardrailPolicy } from './guardrails/index.js';
+import { a as McpServer } from './client-B8DT1vUG.js';
+import { j as AgentLifecycle, G as AgentObservabilityOptions, o as AgentRunOptions, n as AgentResult, t as AgentStream, u as AgentStreamEvent, b as AgentApprovalRequiredResult, A as AgentApprovalDecision, a as AgentApprovalRequiredEvent } from './types-3x3mOLHU.js';
+import { A as AgentMiddleware } from './middleware-C7PdmKF7.js';
+import { A as AnyTool, T as Tool, c as ToolCallContext, N as NormalizedToolOutput } from './tool--Mz4v1eL.js';
+import { D as MemoryStore, y as MemorySavePolicy, m as MemoryCompactor, d as MemoryCompactionConflictRetryOptions, x as MemoryOptions } from './types-BVzM4RsC.js';
+import { a as SkillSet } from './types-DiJqJejp.js';
+import { T as ToolIndex } from './dynamic-tools-KwEGRbHp.js';
+import { E as EmbeddingModel, c as SparseEmbeddingModel } from './types-Cr4uiYo5.js';
+import { V as VectorFilter, a as VectorSearchResult, d as VectorStore, H as HybridVectorStore, e as VectorFusion } from './types-Dld1TpWj.js';
+
+type VectorContextBaseOptions<T = unknown> = {
+    topK: number;
+    minScore?: number | undefined;
+    filter?: VectorFilter | undefined;
+    retries?: RetrySetting | undefined;
+    format?(result: VectorSearchResult<T>): Document;
+};
+type CreateVectorContextOptions<T = unknown> = VectorContextBaseOptions<T> & {
+    store: VectorStore<T>;
+    model: EmbeddingModel;
+    models?: never;
+};
+type CreateHybridVectorContextOptions<T = unknown> = VectorContextBaseOptions<T> & {
+    store: HybridVectorStore<T>;
+    model?: never;
+    models: {
+        dense: EmbeddingModel;
+        sparse: SparseEmbeddingModel;
+    };
+    fusion?: VectorFusion | undefined;
+};
+type VectorContext<T = unknown> = (CreateVectorContextOptions<T> | CreateHybridVectorContextOptions<T>) & {
+    readonly kind: "vector-context";
+};
+declare function createVectorContext<T>(options: CreateVectorContextOptions<T>): VectorContext<T>;
+declare function createVectorContext<T>(options: CreateHybridVectorContextOptions<T>): VectorContext<T>;
+declare function isVectorContext(value: unknown): value is VectorContext;
+
+type AgentToolInput = AnyTool | ProviderTool | ToolIndex;
+type AgentContextInput<T = unknown> = Document | VectorContext<T>;
+type RawResponseOf$1<Model> = Model extends CompletionModel<infer RawResponse> ? RawResponse : unknown;
+type AgentOptions<Output = string, M extends CompletionModel = CompletionModel, ContextDocument = unknown> = {
+    id: string;
+    name?: string | undefined;
+    description?: string | undefined;
+    model: M;
+    instructions?: string | undefined;
+    context?: readonly AgentContextInput<ContextDocument>[] | undefined;
+    tools?: readonly AgentToolInput[] | undefined;
+    mcpServers?: readonly McpServer[] | undefined;
+    skills?: SkillSet | undefined;
+    temperature?: number | undefined;
+    maxTokens?: number | undefined;
+    providerOptions?: JsonObject | undefined;
+    retries?: RetrySetting | undefined;
+    toolChoice?: ToolChoice | undefined;
+    maxTurns?: number | undefined;
+    lifecycle?: AgentLifecycle<Output, RawResponseOf$1<M>> | undefined;
+    outputSchema?: ZodSchema<Output> | undefined;
+    observability?: AgentObservabilityOptions | undefined;
+    guardrails?: GuardrailPolicyInput | undefined;
+    middlewares?: readonly AgentMiddleware[] | undefined;
+    memory?: AgentMemoryOptions | undefined;
+};
+type AgentMemoryOptions = MemoryOptions & {
+    store: MemoryStore;
+};
+type AgentMemory = {
+    store: MemoryStore;
+    savePolicy: MemorySavePolicy;
+    compaction?: {
+        trigger: {
+            afterMessages: number;
+        };
+        retention: {
+            recentUserTurns: number;
+        };
+        compactor: MemoryCompactor;
+        conflictRetries: false | MemoryCompactionConflictRetryOptions;
+    } | undefined;
+};
+type ResolvedAgentOptions<Output = string, M extends CompletionModel = CompletionModel, ContextDocument = unknown> = {
+    id: string;
+    name?: string | undefined;
+    description?: string | undefined;
+    model: M;
+    instructions?: string | undefined;
+    context?: readonly AgentContextInput<ContextDocument>[] | undefined;
+    temperature?: number | undefined;
+    maxTokens?: number | undefined;
+    providerOptions?: JsonObject | undefined;
+    retries?: RetrySetting | undefined;
+    tools?: readonly AnyTool[] | undefined;
+    mcpServers?: readonly McpServer[] | undefined;
+    providerTools?: readonly ProviderTool[] | undefined;
+    toolIndexes?: readonly ToolIndex[] | undefined;
+    toolChoice?: ToolChoice | undefined;
+    defaultMaxTurns?: number | undefined;
+    lifecycle?: AgentLifecycle<Output, RawResponseOf$1<M>> | undefined;
+    outputSchema?: ZodSchema<Output> | undefined;
+    observability?: AgentObservabilityOptions | undefined;
+    guardrails?: readonly GuardrailPolicy[] | undefined;
+    middlewares?: readonly AgentMiddleware[] | undefined;
+    memory?: AgentMemory | undefined;
+};
+type AgentToolOptions = {
+    name: string;
+    description?: string | undefined;
+    maxTurns?: number | undefined;
+    stream?: boolean | undefined;
+};
+
+type RawResponseOf<Model> = Model extends CompletionModel<infer RawResponse> ? RawResponse : unknown;
+declare class Agent<Output = string, M extends CompletionModel = CompletionModel, ContextDocument = unknown> {
+    readonly id: string;
+    readonly name: string | undefined;
+    readonly description: string | undefined;
+    readonly model: M;
+    readonly instructions: string | undefined;
+    readonly context: readonly AgentContextInput<ContextDocument>[];
+    readonly temperature: number | undefined;
+    readonly maxTokens: number | undefined;
+    readonly providerOptions: JsonObject | undefined;
+    readonly retries: RetrySetting | undefined;
+    readonly mcpServers: readonly McpServer[];
+    readonly tools: readonly AnyTool[];
+    readonly toolChoice: ToolChoice | undefined;
+    readonly defaultMaxTurns: number | undefined;
+    readonly lifecycle: AgentLifecycle<Output, RawResponseOf<M>> | undefined;
+    readonly outputSchema: ZodSchema<Output> | undefined;
+    readonly observability: AgentObservabilityOptions | undefined;
+    readonly guardrails: readonly GuardrailPolicy[];
+    readonly middlewares: readonly AgentMiddleware[];
+    readonly memory: AgentMemory | undefined;
+    constructor(options: AgentOptions<Output, M, ContextDocument>);
+    generate(options: AgentRunOptions<Output, RawResponseOf<M>>): Promise<AgentResult<Output>>;
+    stream(options: AgentRunOptions<Output, RawResponseOf<M>>): AgentStream<AgentStreamEvent<Output, RawResponseOf<M>>>;
+    resume(pending: AgentApprovalRequiredResult, decision: AgentApprovalDecision): Promise<AgentResult<Output>>;
+    resume(pending: AgentApprovalRequiredEvent, decision: AgentApprovalDecision): AgentStream<AgentStreamEvent<Output, RawResponseOf<M>>>;
+    asTool(options: AgentToolOptions): Tool<{
+        prompt: string;
+    }, Output>;
+    getTool(toolName: string): AnyTool | undefined;
+    callTool(toolName: string, args: string, context?: ToolCallContext): Promise<NormalizedToolOutput>;
+}
+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>;
+
+export { Agent as A, type CreateHybridVectorContextOptions as C, type ResolvedAgentOptions as R, type VectorContext as V, type AgentContextInput as a, type AgentMemory as b, type AgentMemoryOptions as c, type AgentOptions as d, type AgentToolInput as e, type AgentToolOptions as f, type CreateVectorContextOptions as g, type VectorContextBaseOptions as h, createVectorContext as i, isVectorContext as j, createResolvedAgent as k, getResolvedAgentOptions as l };

package/dist/chunk-4WI3VGZK.js

@@ -0,0 +1,127 @@
+import {
+  CompletionCapabilityError,
+  Usage,
+  generateCompletion
+} from "./chunk-KR3RCCHJ.js";
+import {
+  toProviderJsonSchema
+} from "./chunk-TIZYTPJO.js";
+import {
+  isAbortError,
+  resolveRetryOptions,
+  retryDelayMs,
+  retryOptionsForFailure,
+  waitForRetry
+} from "./chunk-FN7HLLAZ.js";
+
+// src/extractor/extractor.ts
+import { z } from "zod";
+var SUBMIT_TOOL_NAME = "submit";
+var DEFAULT_EXTRACTOR_INSTRUCTIONS = "You are an AI assistant whose purpose is to extract structured data from the provided text.\nYou have access to a `submit` function that defines the structure of the data to extract.\nAlways call the `submit` function with the structured data. Use default or null values when information is missing.";
+var ExtractionError = class extends Error {
+  attempts;
+  usage;
+  constructor(message, options) {
+    super(message, options.cause === void 0 ? void 0 : { cause: options.cause });
+    this.name = "ExtractionError";
+    this.attempts = options.attempts;
+    this.usage = options.usage;
+  }
+};
+async function extract(options) {
+  if (!(options.outputSchema instanceof z.ZodType)) {
+    throw new TypeError("extract outputSchema must be a Zod schema.");
+  }
+  if (typeof options.text !== "string") {
+    throw new TypeError("extract text must be a string.");
+  }
+  const retries = resolveExtractionRetries(options.retries);
+  const maxAttempts = retries?.maxAttempts ?? 1;
+  const submitTool = createSubmitTool(options.outputSchema);
+  const instructions = extractionInstructions(options.instructions);
+  let usage = Usage.empty();
+  let lastError;
+  for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+    try {
+      const result = await generateCompletion({
+        model: options.model,
+        prompt: options.text,
+        instructions,
+        tools: [globalThis.structuredClone(submitTool)],
+        temperature: options.temperature,
+        maxTokens: options.maxTokens,
+        providerOptions: options.providerOptions,
+        toolChoice: "required",
+        retries: false,
+        abortSignal: options.abortSignal
+      });
+      usage = Usage.add(usage, result.usage);
+      return {
+        ...result,
+        output: extractSubmittedData(result.content, options.outputSchema),
+        usage
+      };
+    } catch (error) {
+      if (error instanceof CompletionCapabilityError || isAbortError(error)) {
+        throw error;
+      }
+      lastError = error;
+      const retryOptions = retryOptionsForFailure(retries, {
+        error,
+        attempt,
+        streaming: false
+      });
+      if (retryOptions === void 0) {
+        throw new ExtractionError("No data extracted", {
+          cause: lastError,
+          attempts: attempt,
+          usage
+        });
+      }
+      await waitForRetry(retryDelayMs(retryOptions, attempt), options.abortSignal);
+    }
+  }
+  throw new ExtractionError("No data extracted", {
+    cause: lastError,
+    attempts: maxAttempts,
+    usage
+  });
+}
+function extractionInstructions(instructions) {
+  return instructions === void 0 || instructions.length === 0 ? DEFAULT_EXTRACTOR_INSTRUCTIONS : `${DEFAULT_EXTRACTOR_INSTRUCTIONS}
+
+${instructions}`;
+}
+function createSubmitTool(outputSchema) {
+  return {
+    name: SUBMIT_TOOL_NAME,
+    description: "Submit the structured data extracted from the provided text.",
+    parameters: toProviderJsonSchema(outputSchema, { io: "input" })
+  };
+}
+function resolveExtractionRetries(options) {
+  if (options === void 0 || options === false) {
+    return void 0;
+  }
+  return resolveRetryOptions({
+    ...options,
+    shouldRetry: options.shouldRetry ?? (() => true)
+  });
+}
+function extractSubmittedData(content, schema) {
+  const submitted = content.filter((item) => item.type === "tool-call").filter((toolCall) => toolCall.toolName === SUBMIT_TOOL_NAME).at(-1);
+  if (submitted === void 0) {
+    throw new Error("The model did not call the submit tool");
+  }
+  try {
+    return schema.parse(submitted.input);
+  } catch (error) {
+    throw new Error("Submitted data failed output schema validation", { cause: error });
+  }
+}
+
+export {
+  ExtractionError,
+  extract
+};
+//# sourceMappingURL=chunk-4WI3VGZK.js.map

package/dist/chunk-4WI3VGZK.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/extractor/extractor.ts"],"sourcesContent":["import { z } from \"zod\";\nimport {\n  type AssistantContentPart,\n  CompletionCapabilityError,\n  type CompletionModel,\n  type CompletionResult,\n  generateCompletion,\n  type JsonObject,\n  type ToolDefinition,\n  Usage,\n} from \"../completion/index\";\nimport { isAbortError } from \"../internal/abort\";\nimport {\n  type ResolvedRetryOptions,\n  type RetrySetting,\n  resolveRetryOptions,\n  retryDelayMs,\n  retryOptionsForFailure,\n  waitForRetry,\n} from \"../retry\";\nimport { toProviderJsonSchema, type ZodSchema } from \"../schema/zod-schema\";\n\nconst SUBMIT_TOOL_NAME = \"submit\";\n\nconst DEFAULT_EXTRACTOR_INSTRUCTIONS =\n  \"You are an AI assistant whose purpose is to extract structured data from the provided text.\\n\" +\n  \"You have access to a `submit` function that defines the structure of the data to extract.\\n\" +\n  \"Always call the `submit` function with the structured data. Use default or null values when information is missing.\";\n\ntype RawResponseOf<Model> =\n  Model extends CompletionModel<infer RawResponse> ? RawResponse : unknown;\n\nexport type ExtractOptions<Output, Model extends CompletionModel = CompletionModel> = {\n  model: Model;\n  text: string;\n  outputSchema: ZodSchema<Output>;\n  instructions?: string | undefined;\n  retries?: RetrySetting | undefined;\n  temperature?: number | undefined;\n  maxTokens?: number | undefined;\n  providerOptions?: JsonObject | undefined;\n  abortSignal?: AbortSignal | undefined;\n};\n\nexport type ExtractionResult<Output, RawResponse = unknown> = Omit<\n  CompletionResult<string, RawResponse>,\n  \"output\"\n> & {\n  output: Output;\n};\n\nexport class ExtractionError extends Error {\n  readonly attempts: number;\n  readonly usage: Usage;\n\n  constructor(\n    message: string,\n    options: {\n      cause?: unknown;\n      attempts: number;\n      usage: Usage;\n    },\n  ) {\n    super(message, options.cause === undefined ? undefined : { cause: options.cause });\n    this.name = \"ExtractionError\";\n    this.attempts = options.attempts;\n    this.usage = options.usage;\n  }\n}\n\n/** Extract structured data from text using a required, schema-backed submit tool. */\nexport async function extract<Output, Model extends CompletionModel>(\n  options: ExtractOptions<Output, Model>,\n): Promise<ExtractionResult<Output, RawResponseOf<Model>>> {\n  if (!(options.outputSchema instanceof z.ZodType)) {\n    throw new TypeError(\"extract outputSchema must be a Zod schema.\");\n  }\n  if (typeof options.text !== \"string\") {\n    throw new TypeError(\"extract text must be a string.\");\n  }\n\n  const retries = resolveExtractionRetries(options.retries);\n  const maxAttempts = retries?.maxAttempts ?? 1;\n  const submitTool = createSubmitTool(options.outputSchema);\n  const instructions = extractionInstructions(options.instructions);\n  let usage = Usage.empty();\n  let lastError: unknown;\n\n  for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {\n    try {\n      const result = await generateCompletion({\n        model: options.model,\n        prompt: options.text,\n        instructions,\n        tools: [globalThis.structuredClone(submitTool)],\n        temperature: options.temperature,\n        maxTokens: options.maxTokens,\n        providerOptions: options.providerOptions,\n        toolChoice: \"required\",\n        retries: false,\n        abortSignal: options.abortSignal,\n      });\n      usage = Usage.add(usage, result.usage);\n      return {\n        ...result,\n        output: extractSubmittedData(result.content, options.outputSchema),\n        usage,\n      };\n    } catch (error) {\n      if (error instanceof CompletionCapabilityError || isAbortError(error)) {\n        throw error;\n      }\n      lastError = error;\n      const retryOptions = retryOptionsForFailure(retries, {\n        error,\n        attempt,\n        streaming: false,\n      });\n      if (retryOptions === undefined) {\n        throw new ExtractionError(\"No data extracted\", {\n          cause: lastError,\n          attempts: attempt,\n          usage,\n        });\n      }\n      await waitForRetry(retryDelayMs(retryOptions, attempt), options.abortSignal);\n    }\n  }\n\n  throw new ExtractionError(\"No data extracted\", {\n    cause: lastError,\n    attempts: maxAttempts,\n    usage,\n  });\n}\n\nfunction extractionInstructions(instructions: string | undefined): string {\n  return instructions === undefined || instructions.length === 0\n    ? DEFAULT_EXTRACTOR_INSTRUCTIONS\n    : `${DEFAULT_EXTRACTOR_INSTRUCTIONS}\\n\\n${instructions}`;\n}\n\nfunction createSubmitTool<Output>(outputSchema: ZodSchema<Output>): ToolDefinition {\n  return {\n    name: SUBMIT_TOOL_NAME,\n    description: \"Submit the structured data extracted from the provided text.\",\n    parameters: toProviderJsonSchema(outputSchema, { io: \"input\" }),\n  };\n}\n\nfunction resolveExtractionRetries(\n  options: RetrySetting | undefined,\n): ResolvedRetryOptions | undefined {\n  if (options === undefined || options === false) {\n    return undefined;\n  }\n  return resolveRetryOptions({\n    ...options,\n    shouldRetry: options.shouldRetry ?? (() => true),\n  });\n}\n\nfunction extractSubmittedData<Output>(\n  content: readonly AssistantContentPart[],\n  schema: ZodSchema<Output>,\n): Output {\n  const submitted = content\n    .filter((item) => item.type === \"tool-call\")\n    .filter((toolCall) => toolCall.toolName === SUBMIT_TOOL_NAME)\n    .at(-1);\n\n  if (submitted === undefined) {\n    throw new Error(\"The model did not call the submit tool\");\n  }\n\n  try {\n    return schema.parse(submitted.input);\n  } catch (error) {\n    throw new Error(\"Submitted data failed output schema validation\", { cause: error });\n  }\n}\n"],"mappings":"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","names":[]}