@anvia/core 0.26.0 → 1.0.0-rc.10

package/dist/tool-BpqpoRSE.d.ts

@@ -0,0 +1,58 @@
+import { J as JsonObject, w as ToolDefinition, p as JsonValue, z as ToolResultOutput, y as ToolResultContentPart } from './types-DgvozfPc.js';
+
+type ToolApprovalRunContext = {
+    agentId: string;
+    runId: string;
+    sessionId?: string;
+    metadata?: JsonObject;
+};
+type ToolApprovalContext<Args = unknown> = {
+    toolName: string;
+    args: Args;
+    rawArgs: string;
+    toolCallId: string;
+    callId?: string;
+    internalCallId: string;
+    run: ToolApprovalRunContext;
+};
+type ToolApprovalRequirement = {
+    reason?: string | undefined;
+};
+type ToolRequiresApproval<Args = unknown> = boolean | ToolApprovalRequirement | ((args: Args, context: ToolApprovalContext<Args>) => boolean | ToolApprovalRequirement | Promise<boolean | ToolApprovalRequirement>);
+type ToolCallStreamEvent = {
+    agentId: string;
+    agentName?: string | undefined;
+    event: unknown;
+};
+type ToolCallContext = {
+    emitStreamEvent?(event: ToolCallStreamEvent): void | Promise<void>;
+    abortSignal?: AbortSignal | undefined;
+};
+interface Tool<Args = unknown, Output = unknown> {
+    readonly name: string;
+    readonly requiresApproval?: ToolRequiresApproval<Args>;
+    definition(prompt: string): ToolDefinition | Promise<ToolDefinition>;
+    call(args: Args, context?: ToolCallContext): Output | Promise<Output>;
+    parseInput?(args: JsonValue): Args;
+}
+type AnyTool = Omit<Tool<unknown, unknown>, "requiresApproval"> & {
+    readonly requiresApproval?: unknown;
+};
+declare const richToolOutput: unique symbol;
+type RichToolOutput = Readonly<{
+    [richToolOutput]: true;
+    content: readonly ToolResultContentPart[];
+}>;
+type NormalizedToolOutput = ToolResultOutput;
+declare class ToolResultSerializationError extends TypeError {
+    readonly output: unknown;
+    constructor(output: unknown);
+}
+declare const ToolOutput: {
+    content(content: readonly ToolResultContentPart[]): RichToolOutput;
+};
+declare function normalizeToolResultOutput(output: unknown): NormalizedToolOutput;
+declare function toolResultContentToText(content: readonly ToolResultContentPart[]): string;
+declare function parseToolArgs(args: string): JsonValue;
+
+export { type AnyTool as A, type NormalizedToolOutput as N, type RichToolOutput as R, type Tool as T, type ToolApprovalContext as a, type ToolApprovalRequirement as b, type ToolCallContext as c, type ToolCallStreamEvent as d, type ToolRequiresApproval as e, type ToolApprovalRunContext as f, ToolOutput as g, ToolResultSerializationError as h, normalizeToolResultOutput as n, parseToolArgs as p, toolResultContentToText as t };

package/dist/transcription/index.d.ts

@@ -1,36 +1,43 @@
-import { l as JsonValue } from '../types-G12i56s2.js';
+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-DgvozfPc.js';
 
 type TranscriptionRequest = {
     data: Uint8Array;
     filename: string;
+    mediaType?: string | undefined;
     language?: string | undefined;
     prompt?: string | undefined;
     temperature?: number | undefined;
-    additionalParams?: JsonValue | undefined;
+    providerOptions?: JsonObject | undefined;
 };
-type TranscriptionResponse<RawResponse = unknown> = {
+type TranscriptionResult<RawResponse = unknown> = {
     text: string;
     rawResponse: RawResponse;
 };
-interface TranscriptionModel<RawResponse = unknown, ModelName extends string = string> {
-    readonly provider?: string | undefined;
-    readonly defaultModel?: ModelName | undefined;
-    transcription(request: TranscriptionRequest): Promise<TranscriptionResponse<RawResponse>>;
+interface TranscriptionModel<RawResponse = unknown> {
+    readonly provider: string;
+    readonly modelId: string | undefined;
+    transcription(request: TranscriptionRequest, options?: ModelCallOptions): Promise<TranscriptionResult<RawResponse>>;
 }
 
-declare class TranscriptionRequestBuilder<Model extends TranscriptionModel = TranscriptionModel> {
-    private readonly model;
-    private request;
-    constructor(model: Model);
-    data(data: Uint8Array | ArrayBuffer): this;
-    filename(filename: string): this;
-    language(language: string): this;
-    prompt(prompt: string): this;
-    temperature(temperature: number): this;
-    additionalParams(additionalParams: JsonValue): this;
-    build(): TranscriptionRequest;
-    send(): Promise<Awaited<ReturnType<Model["transcription"]>>>;
-}
-declare function transcriptionRequest<Model extends TranscriptionModel>(model: Model): TranscriptionRequestBuilder<Model>;
+type TranscriptionAudio = {
+    data: Uint8Array | ArrayBuffer;
+    filename: string;
+    mediaType?: string | undefined;
+};
+type TranscribeOptions<Model extends TranscriptionModel = TranscriptionModel> = {
+    model: Model;
+    audio: TranscriptionAudio;
+    language?: string | undefined;
+    prompt?: string | undefined;
+    temperature?: number | undefined;
+    providerOptions?: JsonObject | undefined;
+    retries?: RetrySetting | undefined;
+    abortSignal?: AbortSignal | undefined;
+};
+type RawResponseOf<Model> = Model extends TranscriptionModel<infer RawResponse> ? RawResponse : unknown;
+declare function transcribe<Model extends TranscriptionModel>(options: TranscribeOptions<Model>): Promise<TranscriptionResult<RawResponseOf<Model>>>;
 
-export { type TranscriptionModel, type TranscriptionRequest, TranscriptionRequestBuilder, type TranscriptionResponse, transcriptionRequest };
+export { ModelCallOptions, RetrySetting, type TranscribeOptions, type TranscriptionAudio, type TranscriptionModel, type TranscriptionRequest, type TranscriptionResult, transcribe };

package/dist/transcription/index.js

@@ -1,60 +1,10 @@
-// src/transcription/request.ts
-var TranscriptionRequestBuilder = class {
-  constructor(model) {
-    this.model = model;
-  }
-  model;
-  request = {
-    data: new Uint8Array(),
-    filename: "file"
-  };
-  data(data) {
-    this.request = { ...this.request, data: toUint8Array(data) };
-    return this;
-  }
-  filename(filename) {
-    this.request = { ...this.request, filename };
-    return this;
-  }
-  language(language) {
-    this.request = { ...this.request, language };
-    return this;
-  }
-  prompt(prompt) {
-    this.request = { ...this.request, prompt };
-    return this;
-  }
-  temperature(temperature) {
-    this.request = { ...this.request, temperature };
-    return this;
-  }
-  additionalParams(additionalParams) {
-    this.request = { ...this.request, additionalParams };
-    return this;
-  }
-  build() {
-    if (this.request.data.byteLength === 0) {
-      throw new Error("Transcription data cannot be empty.");
-    }
-    return { ...this.request, data: toUint8Array(this.request.data) };
-  }
-  send() {
-    return this.model.transcription(this.build());
-  }
-};
-function transcriptionRequest(model) {
-  return new TranscriptionRequestBuilder(model);
-}
-function toUint8Array(bytes) {
-  if (bytes instanceof Uint8Array) {
-    return new Uint8Array(
-      bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength)
-    );
-  }
-  return new Uint8Array(bytes);
-}
+import {
+  transcribe
+} from "../chunk-T2C3CGDQ.js";
+import "../chunk-7JLAIN6E.js";
+import "../chunk-3XQGVDU5.js";
+import "../chunk-3RWESPUG.js";
 export {
-  TranscriptionRequestBuilder,
-  transcriptionRequest
+  transcribe
 };
 //# sourceMappingURL=index.js.map

package/dist/transcription/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/transcription/request.ts"],"sourcesContent":["import type { JsonValue } from \"../completion\";\nimport type { TranscriptionModel, TranscriptionRequest } from \"./types\";\n\nexport class TranscriptionRequestBuilder<Model extends TranscriptionModel = TranscriptionModel> {\n  private request: TranscriptionRequest = {\n    data: new Uint8Array(),\n    filename: \"file\",\n  };\n\n  constructor(private readonly model: Model) {}\n\n  data(data: Uint8Array | ArrayBuffer): this {\n    this.request = { ...this.request, data: toUint8Array(data) };\n    return this;\n  }\n\n  filename(filename: string): this {\n    this.request = { ...this.request, filename };\n    return this;\n  }\n\n  language(language: string): this {\n    this.request = { ...this.request, language };\n    return this;\n  }\n\n  prompt(prompt: string): this {\n    this.request = { ...this.request, prompt };\n    return this;\n  }\n\n  temperature(temperature: number): this {\n    this.request = { ...this.request, temperature };\n    return this;\n  }\n\n  additionalParams(additionalParams: JsonValue): this {\n    this.request = { ...this.request, additionalParams };\n    return this;\n  }\n\n  build(): TranscriptionRequest {\n    if (this.request.data.byteLength === 0) {\n      throw new Error(\"Transcription data cannot be empty.\");\n    }\n    return { ...this.request, data: toUint8Array(this.request.data) };\n  }\n\n  send(): Promise<Awaited<ReturnType<Model[\"transcription\"]>>> {\n    return this.model.transcription(this.build()) as Promise<\n      Awaited<ReturnType<Model[\"transcription\"]>>\n    >;\n  }\n}\n\nexport function transcriptionRequest<Model extends TranscriptionModel>(\n  model: Model,\n): TranscriptionRequestBuilder<Model> {\n  return new TranscriptionRequestBuilder(model);\n}\n\nfunction toUint8Array(bytes: Uint8Array | ArrayBuffer): Uint8Array {\n  if (bytes instanceof Uint8Array) {\n    return new Uint8Array(\n      bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength),\n    );\n  }\n  return new Uint8Array(bytes);\n}\n"],"mappings":";AAGO,IAAM,8BAAN,MAAyF;AAAA,EAM9F,YAA6B,OAAc;AAAd;AAAA,EAAe;AAAA,EAAf;AAAA,EALrB,UAAgC;AAAA,IACtC,MAAM,IAAI,WAAW;AAAA,IACrB,UAAU;AAAA,EACZ;AAAA,EAIA,KAAK,MAAsC;AACzC,SAAK,UAAU,EAAE,GAAG,KAAK,SAAS,MAAM,aAAa,IAAI,EAAE;AAC3D,WAAO;AAAA,EACT;AAAA,EAEA,SAAS,UAAwB;AAC/B,SAAK,UAAU,EAAE,GAAG,KAAK,SAAS,SAAS;AAC3C,WAAO;AAAA,EACT;AAAA,EAEA,SAAS,UAAwB;AAC/B,SAAK,UAAU,EAAE,GAAG,KAAK,SAAS,SAAS;AAC3C,WAAO;AAAA,EACT;AAAA,EAEA,OAAO,QAAsB;AAC3B,SAAK,UAAU,EAAE,GAAG,KAAK,SAAS,OAAO;AACzC,WAAO;AAAA,EACT;AAAA,EAEA,YAAY,aAA2B;AACrC,SAAK,UAAU,EAAE,GAAG,KAAK,SAAS,YAAY;AAC9C,WAAO;AAAA,EACT;AAAA,EAEA,iBAAiB,kBAAmC;AAClD,SAAK,UAAU,EAAE,GAAG,KAAK,SAAS,iBAAiB;AACnD,WAAO;AAAA,EACT;AAAA,EAEA,QAA8B;AAC5B,QAAI,KAAK,QAAQ,KAAK,eAAe,GAAG;AACtC,YAAM,IAAI,MAAM,qCAAqC;AAAA,IACvD;AACA,WAAO,EAAE,GAAG,KAAK,SAAS,MAAM,aAAa,KAAK,QAAQ,IAAI,EAAE;AAAA,EAClE;AAAA,EAEA,OAA6D;AAC3D,WAAO,KAAK,MAAM,cAAc,KAAK,MAAM,CAAC;AAAA,EAG9C;AACF;AAEO,SAAS,qBACd,OACoC;AACpC,SAAO,IAAI,4BAA4B,KAAK;AAC9C;AAEA,SAAS,aAAa,OAA6C;AACjE,MAAI,iBAAiB,YAAY;AAC/B,WAAO,IAAI;AAAA,MACT,MAAM,OAAO,MAAM,MAAM,YAAY,MAAM,aAAa,MAAM,UAAU;AAAA,IAC1E;AAAA,EACF;AACA,SAAO,IAAI,WAAW,KAAK;AAC7B;","names":[]}
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/type-utils-CtHVDRn_.d.ts

@@ -0,0 +1,6 @@
+type MaybePromise<T> = T | Promise<T>;
+type DeepReadonly<T> = T extends (...args: never[]) => unknown ? T : T extends readonly (infer Item)[] ? readonly DeepReadonly<Item>[] : T extends object ? {
+    readonly [Key in keyof T]: DeepReadonly<T[Key]>;
+} : T;
+
+export type { DeepReadonly as D, MaybePromise as M };

package/dist/types-CXNE592e.d.ts

@@ -0,0 +1,130 @@
+import { b as RetrySetting } from './retry-CjvSlKGW.js';
+import { J as JsonObject } from './types-DgvozfPc.js';
+import { b as VectorMetadataValue, V as VectorMetadata, a as EmbeddedDocument, S as SparseVector, E as EmbeddingModel, c as SparseEmbeddingModel } from './types-Cr4uiYo5.js';
+
+type VectorFilter = {
+    type: "eq";
+    key: string;
+    value: VectorMetadataValue;
+} | {
+    type: "gt";
+    key: string;
+    value: VectorMetadataValue;
+} | {
+    type: "lt";
+    key: string;
+    value: VectorMetadataValue;
+} | {
+    type: "and";
+    filters: [VectorFilter, VectorFilter];
+} | {
+    type: "or";
+    filters: [VectorFilter, VectorFilter];
+};
+type VectorMetric = "cosine" | "euclidean" | "dotProduct";
+type VectorFusion = "rrf" | "dbsf";
+type LshOptions = {
+    type: "lsh";
+    numTables: number;
+    numHyperplanes: number;
+    seed?: number | undefined;
+};
+type IndexStrategy = {
+    type: "bruteForce";
+} | LshOptions;
+type VectorStoreUpsertOptions<T, Metadata extends VectorMetadata = VectorMetadata> = {
+    documents: Array<EmbeddedDocument<T, Metadata>>;
+    providerOptions?: JsonObject | undefined;
+};
+type VectorSearchRequest = {
+    vector: number[];
+    topK: number;
+    minScore?: number | undefined;
+    filter?: VectorFilter | undefined;
+    providerOptions?: JsonObject | undefined;
+    abortSignal?: AbortSignal | undefined;
+};
+type HybridVectorSearchRequest = VectorSearchRequest & {
+    sparseVector: SparseVector;
+    fusion?: VectorFusion | undefined;
+};
+type VectorSearchResult<T = unknown, Metadata extends VectorMetadata = VectorMetadata> = {
+    score: number;
+    id: string;
+    document: T;
+    metadata?: Metadata | undefined;
+};
+type VectorInspectRequest = {
+    limit: number;
+    cursor?: string | undefined;
+    filter?: VectorFilter | undefined;
+    providerOptions?: JsonObject | undefined;
+    abortSignal?: AbortSignal | undefined;
+};
+type VectorInspectItem<T = unknown, Metadata extends VectorMetadata = VectorMetadata> = {
+    id: string;
+    document: T;
+    metadata?: Metadata | undefined;
+};
+type VectorInspectPage<T = unknown, Metadata extends VectorMetadata = VectorMetadata> = {
+    items: Array<VectorInspectItem<T, Metadata>>;
+    nextCursor?: string | undefined;
+    totalCount?: number | undefined;
+};
+interface VectorStore<T = unknown, Metadata extends VectorMetadata = VectorMetadata> {
+    ensure(): Promise<void>;
+    validate(): Promise<void>;
+    upsert(options: VectorStoreUpsertOptions<T, Metadata>): Promise<void>;
+    search(request: VectorSearchRequest): Promise<Array<VectorSearchResult<T, Metadata>>>;
+    inspect?(request: VectorInspectRequest): Promise<VectorInspectPage<T, Metadata>>;
+}
+interface HybridVectorStore<T = unknown, Metadata extends VectorMetadata = VectorMetadata> extends VectorStore<T, Metadata> {
+    searchHybrid(request: HybridVectorSearchRequest): Promise<Array<VectorSearchResult<T, Metadata>>>;
+}
+type RetrieveDocumentsBaseOptions = {
+    query: string;
+    topK: number;
+    minScore?: number | undefined;
+    filter?: VectorFilter | undefined;
+    retries?: RetrySetting | undefined;
+    abortSignal?: AbortSignal | undefined;
+};
+type RetrieveDocumentsOptions<T, Metadata extends VectorMetadata = VectorMetadata> = RetrieveDocumentsBaseOptions & {
+    store: VectorStore<T, Metadata>;
+    model: EmbeddingModel;
+    models?: never;
+};
+type RetrieveHybridDocumentsOptions<T, Metadata extends VectorMetadata = VectorMetadata> = RetrieveDocumentsBaseOptions & {
+    store: HybridVectorStore<T, Metadata>;
+    model?: never;
+    models: {
+        dense: EmbeddingModel;
+        sparse: SparseEmbeddingModel;
+    };
+    fusion?: VectorFusion | undefined;
+};
+type VectorSearchToolBaseOptions = {
+    name: string;
+    description?: string | undefined;
+    topK?: number | undefined;
+    minScore?: number | undefined;
+    filter?: VectorFilter | undefined;
+    retries?: RetrySetting | undefined;
+};
+type DenseVectorSearchToolOptions<T, Metadata extends VectorMetadata = VectorMetadata> = VectorSearchToolBaseOptions & {
+    store: VectorStore<T, Metadata>;
+    model: EmbeddingModel;
+    models?: never;
+};
+type HybridVectorSearchToolOptions<T, Metadata extends VectorMetadata = VectorMetadata> = VectorSearchToolBaseOptions & {
+    store: HybridVectorStore<T, Metadata>;
+    model?: never;
+    models: {
+        dense: EmbeddingModel;
+        sparse: SparseEmbeddingModel;
+    };
+    fusion?: VectorFusion | undefined;
+};
+type VectorSearchToolOptions<T = unknown, Metadata extends VectorMetadata = VectorMetadata> = DenseVectorSearchToolOptions<T, Metadata> | HybridVectorSearchToolOptions<T, Metadata>;
+
+export type { DenseVectorSearchToolOptions as D, HybridVectorStore as H, IndexStrategy as I, LshOptions as L, RetrieveDocumentsOptions as R, VectorFilter as V, VectorSearchResult as a, VectorInspectRequest as b, VectorInspectPage as c, VectorStore as d, VectorFusion as e, RetrieveHybridDocumentsOptions as f, VectorStoreUpsertOptions as g, VectorSearchRequest as h, VectorSearchToolOptions as i, HybridVectorSearchRequest as j, HybridVectorSearchToolOptions as k, RetrieveDocumentsBaseOptions as l, VectorInspectItem as m, VectorMetric as n, VectorSearchToolBaseOptions as o };

package/dist/types-Cr4uiYo5.d.ts

@@ -0,0 +1,99 @@
+import { M as ModelCallOptions } from './model-call-options-CZkSw_xN.js';
+import { b as RetrySetting } from './retry-CjvSlKGW.js';
+
+type Embedding = {
+    document: string;
+    vector: number[];
+};
+type SparseVector = {
+    indices: number[];
+    values: number[];
+};
+type SparseEmbedding = {
+    document: string;
+    vector: SparseVector;
+};
+interface EmbeddingModel {
+    readonly provider: string;
+    readonly modelId: string;
+    readonly dimensions?: number | undefined;
+    readonly maxBatchSize?: number | undefined;
+    embedTexts(texts: string[], options?: ModelCallOptions | undefined): Promise<Embedding[]>;
+}
+/** Sparse lexical/neural encoder used for hybrid retrieval channels. */
+interface SparseEmbeddingModel {
+    readonly provider: string;
+    readonly modelId: string;
+    readonly maxBatchSize?: number | undefined;
+    /** Embed passage/document texts for indexing. */
+    embedTexts(texts: string[], options?: ModelCallOptions | undefined): Promise<SparseEmbedding[]>;
+    /** Embed a search query (may differ from passage encoding for models like SPLADE). */
+    embedQuery(query: string, options?: ModelCallOptions | undefined): Promise<SparseEmbedding>;
+}
+type EmbeddedDocument<T, Metadata extends VectorMetadata = VectorMetadata> = {
+    id: string;
+    document: T;
+    metadata?: Metadata | undefined;
+    embeddings: Embedding[];
+    /** Optional sparse vectors aligned 1:1 with `embeddings` by chunk index. */
+    sparseEmbeddings?: SparseEmbedding[] | undefined;
+};
+type VectorMetadataValue = string | number | boolean | null;
+type VectorMetadata = Record<string, VectorMetadataValue>;
+type EmbeddingOperationOptions = {
+    retries?: RetrySetting | undefined;
+    abortSignal?: AbortSignal | undefined;
+};
+type EmbedTextOptions = EmbeddingOperationOptions & {
+    model: EmbeddingModel;
+    text: string;
+};
+type EmbedTextsOptions = EmbeddingOperationOptions & {
+    model: EmbeddingModel;
+    texts: string[];
+    concurrency?: number | undefined;
+};
+type EmbedSparseTextsOptions = EmbeddingOperationOptions & {
+    model: SparseEmbeddingModel;
+    texts: string[];
+    concurrency?: number | undefined;
+};
+type EmbedSparseQueryOptions = EmbeddingOperationOptions & {
+    model: SparseEmbeddingModel;
+    query: string;
+};
+type EmbedDocumentsBaseOptions<T, Metadata extends VectorMetadata = VectorMetadata> = EmbeddingOperationOptions & {
+    documents: T[];
+    id?: ((document: T, index: number) => string) | undefined;
+    content(document: T, index: number): string | string[];
+    metadata?: ((document: T, index: number) => Metadata | undefined) | undefined;
+    concurrency?: number | undefined;
+};
+type EmbedDocumentsOptions<T, Metadata extends VectorMetadata = VectorMetadata> = EmbedDocumentsBaseOptions<T, Metadata> & {
+    model: EmbeddingModel;
+    models?: never;
+};
+type EmbedHybridDocumentsOptions<T, Metadata extends VectorMetadata = VectorMetadata> = EmbedDocumentsBaseOptions<T, Metadata> & {
+    model?: never;
+    models: {
+        dense: EmbeddingModel;
+        sparse: SparseEmbeddingModel;
+    };
+};
+type EmbedTextResult = {
+    embedding: Embedding;
+};
+type EmbedTextsResult = {
+    embeddings: Embedding[];
+};
+type EmbedSparseTextsResult = {
+    embeddings: SparseEmbedding[];
+};
+type EmbedSparseQueryResult = {
+    embedding: SparseEmbedding;
+};
+type EmbedDocumentsResult<T, Metadata extends VectorMetadata = VectorMetadata> = {
+    documents: Array<EmbeddedDocument<T, Metadata>>;
+};
+
+export type { EmbeddingModel as E, SparseVector as S, VectorMetadata as V, EmbeddedDocument as a, VectorMetadataValue as b, SparseEmbeddingModel as c, EmbedDocumentsOptions as d, EmbedDocumentsResult as e, EmbedHybridDocumentsOptions as f, EmbedSparseQueryOptions as g, EmbedSparseQueryResult as h, EmbedSparseTextsOptions as i, EmbedSparseTextsResult as j, EmbedTextOptions as k, EmbedTextResult as l, EmbedTextsOptions as m, EmbedTextsResult as n, EmbedDocumentsBaseOptions as o, Embedding as p, EmbeddingOperationOptions as q, SparseEmbedding as r };

package/dist/{types-04LqWrmy.d.ts → types-DC1U1XwW.d.ts}

@@ -1,4 +1,4 @@
-import { A as AnyTool } from './tool-Cohdv5GC.js';
+import { A as AnyTool } from './tool-BpqpoRSE.js';
 
 type Skill = {
     readonly name: string;

package/dist/types-DKOXVTcq.d.ts

@@ -0,0 +1,155 @@
+import { U as Usage, J as JsonObject, M as Message, S as SystemMessage, c as CompletionModel } from './types-DgvozfPc.js';
+import { b as RetrySetting } from './retry-CjvSlKGW.js';
+
+type MemorySavePolicy = "message" | "turn" | "run";
+type MemoryScope = {
+    sessionId: string;
+    userId?: string | undefined;
+    metadata?: JsonObject | undefined;
+};
+type MemoryScopeKeyOptions = {
+    includeUserId?: boolean | undefined;
+    metadataKeys?: readonly string[] | undefined;
+};
+type CreateMemoryScopeKeyOptions = MemoryScopeKeyOptions & {
+    scope: MemoryScope;
+};
+type MemoryScopeKeyResolver = MemoryScopeKeyOptions | ((options: {
+    scope: MemoryScope;
+}) => string);
+type MemoryLoadOptions = {
+    scope: MemoryScope;
+};
+type MemoryAppendOptions = {
+    scope: MemoryScope;
+    runId: string;
+    turn: number;
+    messages: Message[];
+};
+type MemoryClearOptions = {
+    scope: MemoryScope;
+};
+type MemoryErrorOptions = {
+    scope: MemoryScope;
+    runId: string;
+    error: unknown;
+    messages: Message[];
+};
+type MemoryConversationListOptions = {
+    limit: number;
+    userId?: string | undefined;
+};
+type MemoryConversationGetOptions = {
+    ref: string;
+};
+type MemoryConversationSummary = {
+    /** Opaque, store-specific reference used to retrieve this exact conversation. */
+    ref: string;
+    sessionId: string;
+    userId?: string | undefined;
+    metadata?: JsonObject | undefined;
+    createdAt: string;
+    updatedAt: string;
+    messageCount: number;
+};
+type MemoryConversationMessage = {
+    position: number;
+    runId: string;
+    turn: number;
+    createdAt: string;
+    message: Message;
+};
+type MemoryConversation = MemoryConversationSummary & {
+    messages: MemoryConversationMessage[];
+};
+/** Optional, read-only discovery surface for developer tooling such as Studio. */
+interface MemoryInspector {
+    listConversations(options: MemoryConversationListOptions): Promise<MemoryConversationSummary[]>;
+    getConversation(options: MemoryConversationGetOptions): Promise<MemoryConversation | undefined>;
+}
+interface MemoryStore {
+    readonly inspector?: MemoryInspector | undefined;
+    readonly compaction?: MemoryCompactionCapability | undefined;
+    load(options: MemoryLoadOptions): Promise<Message[]>;
+    append(options: MemoryAppendOptions): Promise<void>;
+    clear(options: MemoryClearOptions): Promise<void>;
+    recordError?(options: MemoryErrorOptions): Promise<void>;
+}
+type MemoryCompactionMetadata = {
+    version: 1;
+    compactedMessageCount: number;
+};
+type MemoryCompactionMessage = Omit<SystemMessage, "metadata"> & {
+    metadata: {
+        anvia: {
+            memoryCompaction: MemoryCompactionMetadata;
+        };
+    };
+};
+type MemoryCompactionSnapshot = {
+    /** Opaque store revision used to reject stale compaction replacements. */
+    revision: string;
+    messages: Message[];
+};
+type MemoryCompactionSnapshotOptions = {
+    scope: MemoryScope;
+};
+type MemoryCompactionReplacePrefixOptions = {
+    scope: MemoryScope;
+    revision: string;
+    messageCount: number;
+    replacement: MemoryCompactionMessage;
+    runId: string;
+};
+type MemoryCompactionReplacePrefixResult = {
+    status: "committed" | "conflict";
+};
+/** Optional atomic prefix-replacement capability used by automatic memory compaction. */
+interface MemoryCompactionCapability {
+    snapshot(options: MemoryCompactionSnapshotOptions): Promise<MemoryCompactionSnapshot>;
+    replacePrefix(options: MemoryCompactionReplacePrefixOptions): Promise<MemoryCompactionReplacePrefixResult>;
+}
+type MemoryCompactorInput = {
+    scope: MemoryScope;
+    messages: Message[];
+    abortSignal?: AbortSignal | undefined;
+};
+type MemoryCompactorResult = {
+    summary: string;
+    usage?: Usage | undefined;
+};
+type MemoryCompactor = (input: MemoryCompactorInput) => Promise<MemoryCompactorResult>;
+type CreateSummaryMemoryCompactorOptions = {
+    model: CompletionModel;
+    instructions?: string | undefined;
+    maxTokens?: number | undefined;
+    temperature?: number | undefined;
+    providerOptions?: JsonObject | undefined;
+    retries?: RetrySetting | undefined;
+};
+type MemoryCompactionConflictRetryOptions = {
+    maxAttempts: number;
+};
+type MemoryCompactionOptions = {
+    trigger: {
+        afterMessages: number;
+    };
+    retention?: {
+        recentUserTurns?: number | undefined;
+    };
+    compactor: MemoryCompactor;
+    conflictRetries?: false | MemoryCompactionConflictRetryOptions | undefined;
+};
+type MemoryOptions = {
+    savePolicy?: MemorySavePolicy | undefined;
+    compaction?: MemoryCompactionOptions | undefined;
+};
+type MemoryCompactionInfo = {
+    originalMessageCount: number;
+    compactedMessageCount: number;
+    retainedMessageCount: number;
+    attempts: number;
+    usage: Usage;
+};
+
+export type { MemoryScopeKeyOptions as A, MemoryScopeKeyResolver as B, CreateMemoryScopeKeyOptions as C, MemoryStore as D, MemoryAppendOptions as M, CreateSummaryMemoryCompactorOptions as a, MemoryClearOptions as b, MemoryCompactionCapability as c, MemoryCompactionConflictRetryOptions as d, MemoryCompactionInfo as e, MemoryCompactionMessage as f, MemoryCompactionMetadata as g, MemoryCompactionOptions as h, MemoryCompactionReplacePrefixOptions as i, MemoryCompactionReplacePrefixResult as j, MemoryCompactionSnapshot as k, MemoryCompactionSnapshotOptions as l, MemoryCompactor as m, MemoryCompactorInput as n, MemoryCompactorResult as o, MemoryConversation as p, MemoryConversationGetOptions as q, MemoryConversationListOptions as r, MemoryConversationMessage as s, MemoryConversationSummary as t, MemoryErrorOptions as u, MemoryInspector as v, MemoryLoadOptions as w, MemoryOptions as x, MemorySavePolicy as y, MemoryScope as z };