@aigne/core 0.4.211-beta.2 → 1.0.0

package/lib/types/llm-decision-agent.d.ts

@@ -1,14 +1,14 @@
-import { Agent, AgentProcessOptions } from './agent';
-import type { Context, ContextState } from './context';
-import { DataTypeSchema } from './definitions/data-type-schema';
-import { CreateRunnableMemory } from './definitions/memory';
-import { CreateLLMAgentOptions, LLMAgentDefinition } from './llm-agent';
-import { LLMModel } from './llm-model';
-import { MemorableSearchOutput, MemoryItemWithScore } from './memorable';
-import { Runnable, RunnableDefinition } from './runnable';
-import { OrderedRecord } from './utils';
-import { ExtractRunnableInputType, ExtractRunnableOutputType } from './utils/runnable-type';
-import { UnionToIntersection } from './utils/union';
+import { Agent, type AgentProcessOptions } from "./agent";
+import type { Context, ContextState } from "./context";
+import type { DataTypeSchema } from "./definitions/data-type-schema";
+import { type CreateRunnableMemory } from "./definitions/memory";
+import type { CreateLLMAgentOptions, LLMAgentDefinition } from "./llm-agent";
+import type { LLMModel } from "./llm-model";
+import type { MemorableSearchOutput, MemoryItemWithScore } from "./memorable";
+import type { Runnable, RunnableDefinition } from "./runnable";
+import { OrderedRecord } from "./utils";
+import type { ExtractRunnableInputType, ExtractRunnableOutputType } from "./utils/runnable-type";
+import type { UnionToIntersection } from "./utils/union";
 export declare class LLMDecisionAgent<I extends {
     [name: string]: any;
 } = {}, O extends {
@@ -29,21 +29,21 @@ export interface DecisionAgentCaseParameter<R extends Runnable = Runnable> {
 /**
  * Options to create LLMDecisionAgent.
  */
-export interface CreateLLMDecisionAgentOptions<Case extends DecisionAgentCaseParameter, I extends UnionToIntersection<ExtractRunnableInputType<Case['runnable']>, {
+export interface CreateLLMDecisionAgentOptions<Case extends DecisionAgentCaseParameter, I extends UnionToIntersection<ExtractRunnableInputType<Case["runnable"]>, {
     [name: string]: DataTypeSchema;
-}>, O extends UnionToIntersection<ExtractRunnableOutputType<Case['runnable']>, {
+}>, O extends UnionToIntersection<ExtractRunnableOutputType<Case["runnable"]>, {
     [name: string]: DataTypeSchema;
 }>, Memories extends {
     [name: string]: CreateRunnableMemory<I>;
-}, State extends ContextState> extends Pick<CreateLLMAgentOptions<I, O, Memories, State>, 'name' | 'memories' | 'messages' | 'modelOptions'> {
+}, State extends ContextState> extends Pick<CreateLLMAgentOptions<I, O, Memories, State>, "name" | "memories" | "messages" | "modelOptions"> {
     context: Context<State>;
     cases: {
         [name: string]: Case;
     };
 }
-declare function create<Case extends DecisionAgentCaseParameter, I extends UnionToIntersection<ExtractRunnableInputType<Case['runnable']>, {
+declare function create<Case extends DecisionAgentCaseParameter, I extends UnionToIntersection<ExtractRunnableInputType<Case["runnable"]>, {
     [name: string]: DataTypeSchema;
-}>, O extends UnionToIntersection<ExtractRunnableOutputType<Case['runnable']>, {
+}>, O extends UnionToIntersection<ExtractRunnableOutputType<Case["runnable"]>, {
     [name: string]: DataTypeSchema;
 }>, Memories extends {
     [name: string]: CreateRunnableMemory<I> & {
@@ -55,11 +55,11 @@ declare function create<Case extends DecisionAgentCaseParameter, I extends Union
          */
         primary?: boolean;
     };
-}, State extends ContextState>({ context, ...options }: CreateLLMDecisionAgentOptions<Case, I, O, Memories, State>): LLMDecisionAgent<UnionToIntersection<ExtractRunnableInputType<Case['runnable']>, {}>, ExtractRunnableOutputType<Case['runnable']>, {
-    [name in keyof Memories]: MemorableSearchOutput<Memories[name]['memory']>;
+}, State extends ContextState>({ context, ...options }: CreateLLMDecisionAgentOptions<Case, I, O, Memories, State>): LLMDecisionAgent<UnionToIntersection<ExtractRunnableInputType<Case["runnable"]>, {}>, ExtractRunnableOutputType<Case["runnable"]>, {
+    [name in keyof Memories]: MemorableSearchOutput<Memories[name]["memory"]>;
 }, State>;
-export interface LLMDecisionAgentDefinition extends RunnableDefinition, Pick<LLMAgentDefinition, 'modelOptions' | 'messages' | 'primaryMemoryId'> {
-    type: 'llm_decision_agent';
+export interface LLMDecisionAgentDefinition extends RunnableDefinition, Pick<LLMAgentDefinition, "modelOptions" | "messages" | "primaryMemoryId"> {
+    type: "llm_decision_agent";
     cases?: OrderedRecord<LLMDecisionCase>;
 }
 export interface LLMDecisionCase {

package/lib/types/llm-model.d.ts

@@ -1,12 +1,12 @@
-import { Agent } from './agent';
-import { Context } from './context';
-export type Role = 'system' | 'user' | 'assistant' | 'tool';
+import { Agent } from "./agent";
+import type { Context } from "./context";
+export type Role = "system" | "user" | "assistant" | "tool";
 export interface LLMModelInputs {
     messages: LLMModelInputMessage[];
     responseFormat?: {
-        type: 'text';
+        type: "text";
     } | {
-        type: 'json_schema';
+        type: "json_schema";
         jsonSchema: {
             name: string;
             description?: string;
@@ -15,8 +15,8 @@ export interface LLMModelInputs {
         };
     };
     tools?: LLMModelInputTool[];
-    toolChoice?: 'auto' | 'none' | 'required' | {
-        type: 'function';
+    toolChoice?: "auto" | "none" | "required" | {
+        type: "function";
         function: {
             name: string;
             description?: string;
@@ -27,17 +27,17 @@ export interface LLMModelInputs {
 export interface LLMModelInputMessage {
     role: Role;
     content: string | ({
-        type: 'text';
+        type: "text";
         text: string;
     } | {
-        type: 'image_url';
+        type: "image_url";
         imageUrl: {
             url: string;
         };
     })[];
     toolCalls?: {
         id: string;
-        type: 'function';
+        type: "function";
         function: {
             name: string;
             arguments: string;
@@ -46,7 +46,7 @@ export interface LLMModelInputMessage {
     toolCallId?: string;
 }
 export interface LLMModelInputTool {
-    type: 'function';
+    type: "function";
     function: {
         name: string;
         description?: string;
@@ -64,7 +64,7 @@ export interface LLMModelOutputs {
     $text?: string | null;
     toolCalls?: {
         id?: string;
-        type?: 'function';
+        type?: "function";
         function?: {
             name?: string;
             arguments?: string;

package/lib/types/local-function-agent.d.ts

@@ -1,9 +1,9 @@
-import { Agent, AgentProcessOptions } from './agent';
-import type { Context, ContextState } from './context';
-import { DataTypeSchema, SchemaMapType } from './definitions/data-type-schema';
-import { CreateRunnableMemory } from './definitions/memory';
-import { MemorableSearchOutput, MemoryItemWithScore } from './memorable';
-import { RunnableDefinition, RunnableResponse, RunnableResponseChunk } from './runnable';
+import { Agent, type AgentProcessOptions } from "./agent";
+import type { Context, ContextState } from "./context";
+import { type DataTypeSchema, type SchemaMapType } from "./definitions/data-type-schema";
+import { type CreateRunnableMemory } from "./definitions/memory";
+import type { MemorableSearchOutput, MemoryItemWithScore } from "./memorable";
+import type { RunnableDefinition, RunnableResponse, RunnableResponseChunk } from "./runnable";
 export declare class LocalFunctionAgent<I extends {
     [name: string]: any;
 } = {}, O extends {
@@ -23,21 +23,19 @@ export interface LocalFunctionAgentDefinition<I extends {
 }, Memories extends {
     [name: string]: MemoryItemWithScore[];
 }, State extends ContextState> extends RunnableDefinition {
-    type: 'local_function_agent';
+    type: "local_function_agent";
     function?: LocalFunctionFuncType<I, O, Memories, State>;
 }
-export interface LocalFunctionFuncType<I extends {
+export type LocalFunctionFuncType<I extends {
     [name: string]: any;
 }, O extends {
     [name: string]: any;
 }, Memories extends {
     [name: string]: MemoryItemWithScore[];
-}, State extends ContextState> {
-    (input: I, options: {
-        memories: Memories;
-        context: Context<State>;
-    }): Promise<RunnableResponse<O> | AsyncGenerator<RunnableResponseChunk<O>, void>> | AsyncGenerator<RunnableResponseChunk<O>, void>;
-}
+}, State extends ContextState> = (input: I, options: {
+    memories: Memories;
+    context: Context<State>;
+}) => Promise<RunnableResponse<O> | AsyncGenerator<RunnableResponseChunk<O>, void>> | AsyncGenerator<RunnableResponseChunk<O>, void>;
 export interface CreateLocalFunctionAgentOptions<I extends {
     [name: string]: DataTypeSchema;
 }, O extends {
@@ -51,7 +49,7 @@ export interface CreateLocalFunctionAgentOptions<I extends {
     outputs: O;
     memories?: Memories;
     function?: LocalFunctionFuncType<SchemaMapType<I>, SchemaMapType<O>, {
-        [key in keyof Memories]: MemorableSearchOutput<Memories[key]['memory']>;
+        [key in keyof Memories]: MemorableSearchOutput<Memories[key]["memory"]>;
     }, State>;
 }
 declare function create<I extends {
@@ -61,6 +59,6 @@ declare function create<I extends {
 }, Memories extends {
     [name: string]: CreateRunnableMemory<I>;
 }, State extends ContextState>({ context, ...options }: CreateLocalFunctionAgentOptions<I, O, Memories, State>): LocalFunctionAgent<SchemaMapType<I>, SchemaMapType<O>, {
-    [name in keyof Memories]: MemorableSearchOutput<Memories[name]['memory']>;
+    [name in keyof Memories]: MemorableSearchOutput<Memories[name]["memory"]>;
 }, State>;
 export {};

package/lib/types/memorable.d.ts

@@ -1,25 +1,25 @@
-import type { LLMModelInputMessage } from './llm-model';
-import { Runnable } from './runnable';
+import type { LLMModelInputMessage } from "./llm-model";
+import { Runnable } from "./runnable";
 export interface MemoryMetadata {
     [key: string]: any;
 }
 export type MemoryActionItem<T> = {
-    event: 'add';
+    event: "add";
     id: string;
     memory: T;
     metadata?: MemoryMetadata;
 } | {
-    event: 'update';
+    event: "update";
     id: string;
     memory: T;
     oldMemory: T;
     metadata?: MemoryMetadata;
 } | {
-    event: 'delete';
+    event: "delete";
     id: string;
     memory: T;
 } | {
-    event: 'none';
+    event: "none";
     memory: T;
 };
 export interface MemoryItem<T> {
@@ -36,7 +36,7 @@ export interface MemoryItemWithScore<T = any> extends MemoryItem<T> {
 }
 export type MemoryMessage = LLMModelInputMessage;
 export type MemoryActions<T> = {
-    action: 'add';
+    action: "add";
     inputs: {
         messages: MemoryMessage[];
         options?: {
@@ -49,7 +49,7 @@ export type MemoryActions<T> = {
         results: MemoryActionItem<T>[];
     };
 } | {
-    action: 'search';
+    action: "search";
     inputs: {
         query: string;
         options?: {
@@ -64,7 +64,7 @@ export type MemoryActions<T> = {
         results: MemoryItemWithScore<T>[];
     };
 } | {
-    action: 'filter';
+    action: "filter";
     inputs: {
         options?: {
             k?: number;
@@ -78,7 +78,7 @@ export type MemoryActions<T> = {
         results: MemoryItem<T>[];
     };
 } | {
-    action: 'get';
+    action: "get";
     inputs: {
         memoryId: string;
     };
@@ -86,7 +86,7 @@ export type MemoryActions<T> = {
         result: MemoryItem<T> | null;
     };
 } | {
-    action: 'create';
+    action: "create";
     inputs: {
         memory: T;
         options?: {
@@ -99,7 +99,7 @@ export type MemoryActions<T> = {
         result: MemoryItem<T>;
     };
 } | {
-    action: 'update';
+    action: "update";
     inputs: {
         memoryId: string;
         memory: T;
@@ -108,65 +108,65 @@ export type MemoryActions<T> = {
         result: MemoryItem<T> | null;
     };
 } | {
-    action: 'delete';
+    action: "delete";
     inputs: {
         filter: string | string[] | Record<string, any>;
     };
     outputs: {};
 } | {
-    action: 'reset';
+    action: "reset";
     inputs: {};
     outputs: {};
 };
 export interface SortItem {
     field: string;
-    direction: 'asc' | 'desc';
+    direction: "asc" | "desc";
 }
 export type MemorySortOptions = SortItem | SortItem[];
-export declare abstract class Memorable<T, C = undefined> extends Runnable<MemoryActions<T>, MemoryActions<T>['outputs']> {
+export declare abstract class Memorable<T, C = undefined> extends Runnable<MemoryActions<T>, MemoryActions<T>["outputs"]> {
     constructor();
     abstract runner?: MemoryRunner<T, C>;
     abstract add(messages: Extract<MemoryActions<T>, {
-        action: 'add';
-    }>['inputs']['messages'], options?: Extract<MemoryActions<T>, {
-        action: 'add';
-    }>['inputs']['options']): Promise<Extract<MemoryActions<T>, {
-        action: 'add';
-    }>['outputs']>;
+        action: "add";
+    }>["inputs"]["messages"], options?: Extract<MemoryActions<T>, {
+        action: "add";
+    }>["inputs"]["options"]): Promise<Extract<MemoryActions<T>, {
+        action: "add";
+    }>["outputs"]>;
     abstract search(query: Extract<MemoryActions<T>, {
-        action: 'search';
-    }>['inputs']['query'], options?: Extract<MemoryActions<T>, {
-        action: 'search';
-    }>['inputs']['options']): Promise<Extract<MemoryActions<T>, {
-        action: 'search';
-    }>['outputs']>;
+        action: "search";
+    }>["inputs"]["query"], options?: Extract<MemoryActions<T>, {
+        action: "search";
+    }>["inputs"]["options"]): Promise<Extract<MemoryActions<T>, {
+        action: "search";
+    }>["outputs"]>;
     abstract filter(options: Extract<MemoryActions<T>, {
-        action: 'filter';
-    }>['inputs']['options']): Promise<Extract<MemoryActions<T>, {
-        action: 'filter';
-    }>['outputs']>;
+        action: "filter";
+    }>["inputs"]["options"]): Promise<Extract<MemoryActions<T>, {
+        action: "filter";
+    }>["outputs"]>;
     abstract get(memoryId: Extract<MemoryActions<T>, {
-        action: 'get';
-    }>['inputs']['memoryId']): Promise<Extract<MemoryActions<T>, {
-        action: 'get';
-    }>['outputs']>;
+        action: "get";
+    }>["inputs"]["memoryId"]): Promise<Extract<MemoryActions<T>, {
+        action: "get";
+    }>["outputs"]>;
     abstract create(memory: Extract<MemoryActions<T>, {
-        action: 'create';
-    }>['inputs']['memory'], options?: Extract<MemoryActions<T>, {
-        action: 'create';
-    }>['inputs']['options']): Promise<Extract<MemoryActions<T>, {
-        action: 'create';
-    }>['outputs']>;
+        action: "create";
+    }>["inputs"]["memory"], options?: Extract<MemoryActions<T>, {
+        action: "create";
+    }>["inputs"]["options"]): Promise<Extract<MemoryActions<T>, {
+        action: "create";
+    }>["outputs"]>;
     abstract update(memoryId: Extract<MemoryActions<T>, {
-        action: 'update';
-    }>['inputs']['memoryId'], memory: T): Promise<Extract<MemoryActions<T>, {
-        action: 'update';
-    }>['outputs']>;
+        action: "update";
+    }>["inputs"]["memoryId"], memory: T): Promise<Extract<MemoryActions<T>, {
+        action: "update";
+    }>["outputs"]>;
     abstract delete(memoryId: Extract<MemoryActions<T>, {
-        action: 'delete';
-    }>['inputs']['filter']): Promise<Extract<MemoryActions<T>, {
-        action: 'delete';
-    }>['outputs']>;
+        action: "delete";
+    }>["inputs"]["filter"]): Promise<Extract<MemoryActions<T>, {
+        action: "delete";
+    }>["outputs"]>;
     abstract reset(): Promise<void>;
 }
 export interface MemoryRunnerInput<C = undefined> {
@@ -180,4 +180,4 @@ export interface MemoryRunnerInput<C = undefined> {
 export declare abstract class MemoryRunner<T, C = undefined> extends Runnable<MemoryRunnerInput<C>, MemoryActionItem<T>[]> {
     constructor(name: string);
 }
-export type MemorableSearchOutput<T extends Memorable<any>> = Awaited<ReturnType<T['search']>>['results'];
+export type MemorableSearchOutput<T extends Memorable<any>> = Awaited<ReturnType<T["search"]>>["results"];

package/lib/types/open-api-agent.d.ts

@@ -1,11 +1,11 @@
-import { Agent } from './agent';
-import type { Context, ContextState } from './context';
-import { DataTypeSchema, SchemaMapType } from './definitions/data-type-schema';
-import { CreateRunnableMemory } from './definitions/memory';
-import { AuthConfig, FetchRequest, HTTPMethod, OpenAPIDataType, OpenAPIDataTypeSchema } from './definitions/open-api';
-import { MemorableSearchOutput, MemoryItemWithScore } from './memorable';
-import { RunnableDefinition } from './runnable';
-import { OrderedRecord } from './utils';
+import { Agent } from "./agent";
+import type { Context, ContextState } from "./context";
+import { type DataTypeSchema, type SchemaMapType } from "./definitions/data-type-schema";
+import type { CreateRunnableMemory } from "./definitions/memory";
+import type { AuthConfig, FetchRequest, HTTPMethod, OpenAPIDataType, OpenAPIDataTypeSchema } from "./definitions/open-api";
+import type { MemorableSearchOutput, MemoryItemWithScore } from "./memorable";
+import type { RunnableDefinition } from "./runnable";
+import type { OrderedRecord } from "./utils";
 export declare class OpenAPIAgent<I extends {
     [name: string]: any;
 } = {}, O extends {
@@ -16,11 +16,11 @@ export declare class OpenAPIAgent<I extends {
     definition: OpenAPIAgentDefinition;
     static create: typeof create;
     constructor(definition: OpenAPIAgentDefinition, context?: Context<State>);
-    process(input: I): Promise<any>;
-    fetch(request: FetchRequest): Promise<any>;
+    process(input: I): Promise<O>;
+    fetch<T>(request: FetchRequest): Promise<T>;
 }
 export interface OpenAPIAgentDefinition extends RunnableDefinition {
-    type: 'open_api_agent';
+    type: "open_api_agent";
     inputs: OrderedRecord<OpenAPIDataType>;
     url: string;
     method?: HTTPMethod;
@@ -50,6 +50,6 @@ declare function create<I extends {
 }, Memories extends {
     [name: string]: CreateRunnableMemory<I>;
 }, State extends ContextState>({ context, ...options }: CreateOpenAPIAgentOptions<I, O, Memories, State>): OpenAPIAgent<SchemaMapType<I>, SchemaMapType<O>, {
-    [name in keyof Memories]: MemorableSearchOutput<Memories[name]['memory']>;
+    [name in keyof Memories]: MemorableSearchOutput<Memories[name]["memory"]>;
 }, State>;
 export {};

package/lib/types/pipeline-agent.d.ts

@@ -1,12 +1,12 @@
-import { Agent, AgentProcessOptions } from './agent';
-import type { Context, ContextState } from './context';
-import { DataTypeSchema, SchemaMapType } from './definitions/data-type-schema';
-import { CreateRunnableMemory } from './definitions/memory';
-import { MemorableSearchOutput, MemoryItemWithScore } from './memorable';
-import { Runnable, RunnableDefinition, RunnableOutput, RunnableResponseDelta } from './runnable';
-import { MakeNullablePropertyOptional } from './utils/nullable';
-import { OrderedRecord } from './utils/ordered-map';
-import { ExtractRunnableInputType } from './utils/runnable-type';
+import { Agent, type AgentProcessOptions } from "./agent";
+import type { Context, ContextState } from "./context";
+import { type DataTypeSchema, type SchemaMapType } from "./definitions/data-type-schema";
+import { type CreateRunnableMemory } from "./definitions/memory";
+import type { MemorableSearchOutput, MemoryItemWithScore } from "./memorable";
+import type { Runnable, RunnableDefinition, RunnableOutput, RunnableResponseDelta } from "./runnable";
+import type { MakeNullablePropertyOptional } from "./utils/nullable";
+import { OrderedRecord } from "./utils/ordered-map";
+import type { ExtractRunnableInputType } from "./utils/runnable-type";
 export declare class PipelineAgent<I extends {
     [key: string]: any;
 } = {}, O extends {
@@ -17,7 +17,7 @@ export declare class PipelineAgent<I extends {
     definition: PipelineAgentDefinition;
     static create: typeof create;
     constructor(definition: PipelineAgentDefinition, context?: Context<State>);
-    process(input: I, options: AgentProcessOptions<Memories>): Promise<ReadableStream<RunnableResponseDelta<O>>>;
+    process(input: I, options: AgentProcessOptions<Memories>): Promise<import("stream/web").ReadableStream<RunnableResponseDelta<O>>>;
 }
 type VariableWithPropPath = {
     fromVariable: string;
@@ -50,15 +50,15 @@ declare function create<I extends {
     memories?: Memories;
     processes: Processes;
 }): PipelineAgent<SchemaMapType<I>, SchemaMapType<O>, {
-    [name in keyof Memories]: MemorableSearchOutput<Memories[name]['memory']>;
+    [name in keyof Memories]: MemorableSearchOutput<Memories[name]["memory"]>;
 }, State>;
 export interface PipelineAgentDefinition extends RunnableDefinition {
-    type: 'pipeline_agent';
+    type: "pipeline_agent";
     processes?: OrderedRecord<PipelineAgentProcess>;
     outputs: OrderedRecord<PipelineAgentOutput>;
 }
 export type PipelineAgentOutput = RunnableOutput & {
-    from: 'variable';
+    from: "variable";
     fromVariableId?: string;
     fromVariablePropPath?: (string | number)[];
 };
@@ -70,7 +70,7 @@ export type PipelineAgentProcess = {
     };
     input?: {
         [inputId: string]: {
-            from: 'variable';
+            from: "variable";
             fromVariableId?: string;
             fromVariablePropPath?: (string | number | symbol)[];
         };

package/lib/types/runnable.d.ts

@@ -1,7 +1,7 @@
-import type { Context, ContextState } from './context';
-import type { DataType } from './definitions/data-type';
-import type { Memorable } from './memorable';
-import { OrderedRecord } from './utils/ordered-map';
+import type { Context, ContextState } from "./context";
+import type { DataType } from "./definitions/data-type";
+import type { Memorable } from "./memorable";
+import { OrderedRecord } from "./utils/ordered-map";
 export interface RunOptions {
     stream?: boolean;
 }
@@ -44,7 +44,7 @@ export interface RunnableMemory {
     name?: string;
     memory?: Memorable<any>;
     query?: {
-        from: 'variable';
+        from: "variable";
         fromVariableId?: string;
         fromVariablePropPath?: string[];
     };

package/lib/types/utils/fetch-open-api.d.ts

@@ -1,2 +1,2 @@
-import type { FetchRequest } from '../definitions/open-api';
-export declare const fetchOpenApi: (request: FetchRequest) => Promise<any>;
+import type { FetchRequest } from "../definitions/open-api";
+export declare function fetchOpenApi<T>(request: FetchRequest): Promise<T>;

package/lib/types/utils/index.d.ts

@@ -1,10 +1,10 @@
-export * from './fetch';
-export * from './fetch-open-api';
-export * from './is-non-nullable';
-export * from './mustache-utils';
-export * from './nullable';
-export * from './omit';
-export * from './open-api-parameter';
-export * from './ordered-map';
-export * from './stream-utils';
-export * from './union';
+export * from "./fetch";
+export * from "./fetch-open-api";
+export * from "./is-non-nullable";
+export * from "./mustache-utils";
+export * from "./nullable";
+export * from "./omit";
+export * from "./open-api-parameter";
+export * from "./ordered-map";
+export * from "./stream-utils";
+export * from "./union";

package/lib/types/utils/message-utils.d.ts

@@ -1,6 +1,6 @@
-import type { LLMAgentDefinition } from '../llm-agent';
-import type { LLMModelInputMessage } from '../llm-model';
-import type { MemoryItemWithScore } from '../memorable';
+import type { LLMAgentDefinition } from "../llm-agent";
+import type { LLMModelInputMessage } from "../llm-model";
+import type { MemoryItemWithScore } from "../memorable";
 export declare function mergeHistoryMessages(messages: LLMModelInputMessage[], history: LLMModelInputMessage[]): LLMModelInputMessage[];
 export declare function memoriesToMessages(memories: {
     [name: string]: MemoryItemWithScore[];
@@ -10,7 +10,7 @@ export declare function memoriesToMessages(memories: {
     primaryMemory: LLMModelInputMessage[];
     memory: string;
 };
-export declare function prepareMessages(definition: Pick<LLMAgentDefinition, 'messages' | 'memories' | 'primaryMemoryId'>, input: {
+export declare function prepareMessages(definition: Pick<LLMAgentDefinition, "messages" | "memories" | "primaryMemoryId">, input: {
     [name: string]: any;
 }, memories: {
     [name: string]: MemoryItemWithScore[];

package/lib/types/utils/open-api-parameter.d.ts

@@ -1,7 +1,7 @@
-import type { AuthConfig, FetchRequest, HTTPMethod } from '../definitions/open-api';
-import type { OpenAPIAgentDefinition } from '../open-api-agent';
+import type { AuthConfig, FetchRequest, HTTPMethod } from "../definitions/open-api";
+import type { OpenAPIAgentDefinition } from "../open-api-agent";
 export declare function formatOpenAPIRequest(api: {
     url: string;
     method: HTTPMethod;
     auth?: AuthConfig;
-}, inputs: OpenAPIAgentDefinition['inputs'], input: Record<string, any>): Promise<FetchRequest>;
+}, inputs: OpenAPIAgentDefinition["inputs"], input: Record<string, any>): Promise<FetchRequest>;

package/lib/types/utils/runnable-type.d.ts

@@ -1,3 +1,3 @@
-import { Runnable, RunnableResponseStream } from '../runnable';
+import type { Runnable, RunnableResponseStream } from "../runnable";
 export type ExtractRunnableInputType<T> = T extends Runnable<infer I, any> ? I : never;
 export type ExtractRunnableOutputType<T> = T extends Runnable<any, infer O> ? Exclude<O, RunnableResponseStream<any>> : never;

package/lib/types/utils/stream-utils.d.ts

@@ -1,4 +1,4 @@
-import { RunnableResponse, RunnableResponseChunk, RunnableResponseStream } from '../runnable';
+import { type RunnableResponse, type RunnableResponseChunk, type RunnableResponseStream } from "../runnable";
 export declare function objectToRunnableResponseStream<T extends {
     [key: string]: any;
 }>(obj: T): RunnableResponseStream<T>;

package/lib/types/utils/structured-output-schema.d.ts

@@ -1,3 +1,3 @@
-import { RunnableOutput } from '../runnable';
-import { OrderedRecord } from './ordered-map';
+import type { RunnableOutput } from "../runnable";
+import { OrderedRecord } from "./ordered-map";
 export declare function outputsToJsonSchema(outputs: OrderedRecord<RunnableOutput>): object;