@aigne/core 1.0.10 → 1.0.11

package/lib/esm/runnable.d.ts

@@ -1,16 +1,13 @@
 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;
 }
 export type RunnableResponse<T> = T | RunnableResponseStream<T>;
-export declare abstract class Runnable<I extends {
-    [name: string]: any;
-} = {}, O extends {
-    [name: string]: any;
-} = {}, State extends ContextState = ContextState> {
+export type RunnableInput = Record<string, any>;
+export type RunnableOutput = Record<string, any>;
+export declare abstract class Runnable<I extends RunnableInput = RunnableInput, O extends RunnableOutput = RunnableOutput, State extends ContextState = ContextState> {
     definition: RunnableDefinition;
     context?: Context<State> | undefined;
     constructor(definition: RunnableDefinition, context?: Context<State> | undefined);
@@ -35,25 +32,11 @@ export interface RunnableDefinition {
     type: string;
     name?: string;
     description?: string;
-    memories?: OrderedRecord<RunnableMemory>;
-    inputs: OrderedRecord<RunnableInput>;
-    outputs: OrderedRecord<RunnableOutput>;
+    inputs: OrderedRecord<RunnableInputType>;
+    outputs: OrderedRecord<RunnableOutputType>;
 }
-export interface RunnableMemory {
-    id: string;
-    name?: string;
-    memory?: Memorable<any>;
-    query?: {
-        from: "variable";
-        fromVariableId?: string;
-        fromVariablePropPath?: string[];
-    };
-    options?: {
-        k?: number;
-    };
-}
-export type RunnableInput = DataType;
-export type RunnableOutput = DataType;
+export type RunnableInputType = DataType;
+export type RunnableOutputType = DataType;
 export interface RunnableResponseDelta<T> {
     $text?: string;
     delta?: Partial<T>;

package/lib/esm/sandbox-function-agent.d.ts

@@ -1,48 +1,20 @@
-import { Agent, type AgentProcessOptions } from "./agent";
+import { Agent, type AgentDefinition, type AgentMemories, type AgentPreloads, type AgentProcessInput, type AgentProcessOptions, type CreateAgentInputSchema, type CreateAgentMemoriesSchema, type CreateAgentMemoriesType, type CreateAgentOptions, type CreateAgentOutputSchema, type CreateAgentPreloadsSchema, type CreateAgentPreloadsType } 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 } from "./runnable";
+import { type SchemaToType } from "./definitions/data-schema";
+import type { RunnableInput, RunnableOutput } from "./runnable";
 import type { SandboxFunctionRunner } from "./sandbox-function-runner";
-export declare class SandboxFunctionAgent<I extends {
-    [name: string]: any;
-} = {}, O extends {
-    [name: string]: any;
-} = {}, Memories extends {
-    [name: string]: MemoryItemWithScore[];
-} = {}, State extends ContextState = ContextState> extends Agent<I, O, Memories, State> {
+export declare class SandboxFunctionAgent<I extends RunnableInput = RunnableInput, O extends RunnableOutput = RunnableOutput, State extends ContextState = ContextState, Preloads extends AgentPreloads = AgentPreloads, Memories extends AgentMemories = AgentMemories> extends Agent<I, O, State, Preloads, Memories> {
     definition: SandboxFunctionAgentDefinition;
-    runner?: SandboxFunctionRunner<I, O, Memories, State> | undefined;
+    runner?: SandboxFunctionRunner<I, O, State, Preloads, Memories> | undefined;
     static create: typeof create;
-    constructor(definition: SandboxFunctionAgentDefinition, context?: Context<State>, runner?: SandboxFunctionRunner<I, O, Memories, State> | undefined);
-    process(input: I, options: AgentProcessOptions<Memories>): Promise<import("./runnable").RunnableResponseStream<O>>;
+    constructor(definition: SandboxFunctionAgentDefinition, context?: Context<State>, runner?: SandboxFunctionRunner<I, O, State, Preloads, Memories> | undefined);
+    process(input: AgentProcessInput<I, Preloads, Memories>, options: AgentProcessOptions<Preloads, Memories>): Promise<import("./runnable").RunnableResponseStream<O>>;
 }
-export interface CreateSandboxFunctionAgentOptions<I extends {
-    [name: string]: DataTypeSchema;
-}, O extends {
-    [name: string]: DataTypeSchema;
-}, Memories extends {
-    [name: string]: CreateRunnableMemory<I>;
-}, State extends ContextState> {
-    context?: Context<State>;
-    name?: string;
-    inputs: I;
-    outputs: O;
-    memories?: Memories;
+export declare function create<I extends CreateAgentInputSchema, O extends CreateAgentOutputSchema, State extends ContextState, Preloads extends CreateAgentPreloadsSchema<I>, Memories extends CreateAgentMemoriesSchema<I>>(options: CreateAgentOptions<I, O, State, Preloads, Memories> & {
     language?: string;
     code: string;
-}
-export declare function create<I extends {
-    [name: string]: DataTypeSchema;
-}, O extends {
-    [name: string]: DataTypeSchema;
-}, Memories extends {
-    [name: string]: CreateRunnableMemory<I>;
-}, State extends ContextState>({ context, ...options }: CreateSandboxFunctionAgentOptions<I, O, Memories, State>): SandboxFunctionAgent<SchemaMapType<I>, SchemaMapType<O>, {
-    [name in keyof Memories]: MemorableSearchOutput<Memories[name]["memory"]>;
-}, State>;
-export interface SandboxFunctionAgentDefinition extends RunnableDefinition {
+}): SandboxFunctionAgent<SchemaToType<I>, SchemaToType<O>, State, CreateAgentPreloadsType<I, Preloads>, CreateAgentMemoriesType<I, Memories>>;
+export interface SandboxFunctionAgentDefinition extends AgentDefinition {
     type: "sandbox_function_agent";
     language?: string;
     code?: string;

package/lib/esm/sandbox-function-agent.js

@@ -12,10 +12,11 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 };
 import { nanoid } from "nanoid";
 import { inject, injectable } from "tsyringe";
-import { Agent } from "./agent";
+import { Agent, } from "./agent";
 import { TYPES } from "./constants";
-import { schemaToDataType, } from "./definitions/data-type-schema";
-import { toRunnableMemories, } from "./definitions/memory";
+import { schemaToDataType } from "./definitions/data-schema";
+import { toRunnableMemories } from "./definitions/memory";
+import { preloadCreatorsToPreloads } from "./definitions/preload";
 let SandboxFunctionAgent = class SandboxFunctionAgent extends Agent {
     definition;
     runner;
@@ -39,6 +40,7 @@ let SandboxFunctionAgent = class SandboxFunctionAgent extends Agent {
             language,
             code,
             input,
+            preloads: options.preloads,
             memories: options.memories,
             context: { state: context.state },
         }, { stream: true });
@@ -52,10 +54,11 @@ SandboxFunctionAgent = __decorate([
     __metadata("design:paramtypes", [Object, Object, Function])
 ], SandboxFunctionAgent);
 export { SandboxFunctionAgent };
-export function create({ context, ...options }) {
+export function create(options) {
     const agentId = options.name || nanoid();
     const inputs = schemaToDataType(options.inputs);
     const outputs = schemaToDataType(options.outputs);
+    const preloads = preloadCreatorsToPreloads(inputs, options.preloads);
     const memories = toRunnableMemories(agentId, inputs, options.memories ?? {});
     return new SandboxFunctionAgent({
         id: agentId,
@@ -63,8 +66,9 @@ export function create({ context, ...options }) {
         type: "sandbox_function_agent",
         inputs,
         outputs,
+        preloads,
         memories,
         language: options.language,
         code: options.code,
-    }, context);
+    }, options.context);
 }

package/lib/esm/sandbox-function-runner.d.ts

@@ -1,25 +1,16 @@
-import { Agent } from "./agent";
+import { Agent, type AgentMemories, type AgentPreloads } from "./agent";
 import type { Context, ContextState } from "./context";
-import type { MemoryItemWithScore } from "./memorable";
-export interface SandboxFunctionRunnerInput<I extends {
-    [name: string]: any;
-} = {}, Memories extends {
-    [name: string]: MemoryItemWithScore[];
-} = {}, State extends ContextState = ContextState> {
+import type { RunnableInput, RunnableOutput } from "./runnable";
+export type SandboxFunctionRunnerInput<Input extends RunnableInput = RunnableInput, State extends ContextState = ContextState, Preloads extends AgentPreloads = AgentPreloads, Memories extends AgentMemories = AgentMemories> = {
     name: string;
     language?: string;
     code: string;
-    input: I;
+    input: Input;
+    preloads: Preloads;
     memories: Memories;
     context: Pick<Context<State>, "state">;
-}
-export type SandboxFunctionRunnerOutput<O> = O;
-export declare abstract class SandboxFunctionRunner<I extends {
-    [name: string]: any;
-} = {}, O extends {
-    [name: string]: any;
-} = {}, Memories extends {
-    [name: string]: MemoryItemWithScore[];
-} = {}, State extends ContextState = ContextState> extends Agent<SandboxFunctionRunnerInput<I, Memories, State>, SandboxFunctionRunnerOutput<O>> {
+};
+export type SandboxFunctionRunnerOutput<Output extends RunnableOutput> = Output;
+export declare abstract class SandboxFunctionRunner<I extends RunnableInput = RunnableInput, O extends RunnableOutput = RunnableOutput, State extends ContextState = ContextState, Preloads extends AgentPreloads = AgentPreloads, Memories extends AgentMemories = AgentMemories> extends Agent<SandboxFunctionRunnerInput<I, State, Preloads, Memories>, SandboxFunctionRunnerOutput<O>> {
     constructor(context?: Context);
 }

package/lib/esm/sandbox-function-runner.js

@@ -1,4 +1,4 @@
-import { Agent } from "./agent";
+import { Agent, } from "./agent";
 import { OrderedRecord } from "./utils";
 export class SandboxFunctionRunner extends Agent {
     constructor(context) {
@@ -12,6 +12,7 @@ export class SandboxFunctionRunner extends Agent {
                 { id: "language", name: "language", type: "string" },
                 { id: "code", name: "code", type: "string", required: true },
                 { id: "input", name: "input", type: "object", required: true },
+                { id: "preloads", name: "preloads", type: "object", required: true },
                 { id: "memories", name: "memories", type: "object", required: true },
                 { id: "context", name: "context", type: "object", required: true },
             ]),

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

@@ -1,6 +1,7 @@
 export * from "./fetch";
 export * from "./fetch-open-api";
 export * from "./is-non-nullable";
+export * from "./logger";
 export * from "./mustache-utils";
 export * from "./nullable";
 export * from "./omit";

package/lib/esm/utils/index.js

@@ -1,6 +1,7 @@
 export * from "./fetch";
 export * from "./fetch-open-api";
 export * from "./is-non-nullable";
+export * from "./logger";
 export * from "./mustache-utils";
 export * from "./nullable";
 export * from "./omit";

package/lib/esm/utils/logger.d.ts

@@ -0,0 +1,3 @@
+type Logger = Pick<typeof console, "debug" | "info" | "warn" | "error">;
+export declare const logger: Logger;
+export {};

package/lib/esm/utils/logger.js

@@ -0,0 +1,14 @@
+function logLevel() {
+    return process.env.LOG_LEVEL || "info";
+}
+function createLogger(logger, level = logLevel()) {
+    return {
+        debug: level === "debug" ? logger.debug : () => { },
+        info: level === "debug" || level === "info" ? logger.info : () => { },
+        warn: level === "debug" || level === "info" || level === "warn"
+            ? logger.warn
+            : () => { },
+        error: logger.error,
+    };
+}
+export const logger = createLogger(console);

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

@@ -11,7 +11,7 @@ export declare function memoriesToMessages(memories: {
     memory: string;
 };
 export declare function prepareMessages(definition: Pick<LLMAgentDefinition, "messages" | "memories" | "primaryMemoryId">, input: {
-    [name: string]: any;
+    [name: string]: unknown;
 }, memories: {
     [name: string]: MemoryItemWithScore[];
 }): {

package/lib/esm/utils/message-utils.js

@@ -41,12 +41,9 @@ export function memoriesToMessages(memories, { primaryMemoryName } = {}) {
     };
 }
 export function prepareMessages(definition, input, memories) {
-    const variables = { ...input, ...memories };
     const originalMessages = OrderedRecord.toArray(definition.messages).map(({ role, content }) => ({
         role,
-        content: typeof content === "string"
-            ? renderMessage(content, variables)
-            : content,
+        content: typeof content === "string" ? renderMessage(content, input) : content,
     }));
     if (!originalMessages.length)
         throw new Error("Messages are required");

package/lib/esm/utils/open-api-parameter.js

@@ -1,5 +1,5 @@
 import { isEmpty, omitBy } from "lodash";
-import logger from "../logger";
+import { logger } from "./logger";
 import { OrderedRecord } from "./ordered-map";
 export async function formatOpenAPIRequest(api, inputs, input) {
     const { url, method, ...inputParams } = processParameters(api, inputs, input);

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

@@ -1,23 +1,5 @@
-import type { Runnable, RunnableResponseStream } from "../runnable";
+import type { Runnable, RunnableInput, RunnableOutput, RunnableResponseStream } from "../runnable";
 import type { UnionToIntersection } from "./union";
-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;
-export type ExtractRunnableInputTypeIntersection<T> = UnionToIntersection<ExtractRunnableInputType<T>, {}>;
-export type ExtractRunnableOutputTypeIntersection<T> = UnionToIntersection<ExtractRunnableOutputType<T>, {}>;
-export type BindAgentInput = {
-    from: "ai";
-};
-export type PickInputFrom<I, From extends BindAgentInput["from"]> = {
-    [key in keyof I as I[key] extends {
-        from: From;
-    } ? key : never]: I[key];
-};
-export type OmitBoundAgentInput<Case extends BoundAgent, From extends BindAgentInput["from"]> = Omit<UnionToIntersection<ExtractRunnableInputType<Case["runnable"]>, {}>, keyof PickInputFrom<Required<UnionToIntersection<NonNullable<Case["input"]>, {}>>, From>>;
-export type BindAgentInputs<R extends Runnable> = {
-    [key in keyof ExtractRunnableInputType<R>]?: BindAgentInput;
-};
-export interface BoundAgent<R extends Runnable = Runnable, I extends BindAgentInputs<R> = BindAgentInputs<R>> {
-    description?: string;
-    runnable: R;
-    input?: I;
-}
+export type ExtractRunnableInputType<T> = T extends Runnable<infer I, RunnableOutput> ? I : never;
+export type ExtractRunnableOutputType<T> = T extends Runnable<RunnableInput, infer O> ? Exclude<O, RunnableResponseStream<unknown>> : never;
+export type ExtractRunnableInputTypeIntersection<T> = UnionToIntersection<ExtractRunnableInputType<T>, Record<string, unknown>>;

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

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

package/lib/esm/utils/type-utils.d.ts

@@ -0,0 +1 @@
+export type ArrayElement<T> = T extends (infer U)[] ? U : never;

package/lib/esm/utils/type-utils.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aigne/core",
-  "version": "1.0.10",
+  "version": "1.0.11",
   "description": "AIGNE core library",
   "publishConfig": {
     "access": "public"

package/lib/cjs/definitions/data-type-schema.d.ts

@@ -1,42 +0,0 @@
-import type { MakeNullablePropertyOptional } from "../utils/nullable";
-import { OrderedRecord } from "../utils/ordered-map";
-import type { DataType } from "./data-type";
-export declare function schemaToDataType(dataType: {
-    [name: string]: DataTypeSchema;
-}): OrderedRecord<DataType>;
-export type DataTypeSchema = DataTypeSchemaString | DataTypeSchemaNumber | DataTypeSchemaBoolean | DataTypeSchemaObject | DataTypeSchemaArray;
-export interface DataTypeSchemaBase {
-    description?: string;
-    required?: boolean;
-}
-export interface DataTypeSchemaString extends DataTypeSchemaBase {
-    type: "string";
-}
-export interface DataTypeSchemaNumber extends DataTypeSchemaBase {
-    type: "number";
-}
-export interface DataTypeSchemaBoolean extends DataTypeSchemaBase {
-    type: "boolean";
-}
-export interface DataTypeSchemaObject extends DataTypeSchemaBase {
-    type: "object";
-    properties?: {
-        [key: string]: DataTypeSchema;
-    };
-}
-export interface DataTypeSchemaArray extends DataTypeSchemaBase {
-    type: "array";
-    items?: DataTypeSchema;
-}
-type SchemaTypeInner<T extends DataTypeSchema> = T extends DataTypeSchemaString ? string : T extends DataTypeSchemaNumber ? number : T extends DataTypeSchemaBoolean ? boolean : T extends DataTypeSchemaObject ? MakeNullablePropertyOptional<{
-    [K in keyof T["properties"]]: SchemaType<NonNullable<T["properties"]>[K]>;
-}> : T extends DataTypeSchemaArray ? T["items"] extends null | undefined ? SchemaType<{
-    type: "object";
-}>[] : SchemaType<NonNullable<T["items"]>>[] : never;
-export type SchemaType<T extends DataTypeSchema> = T["required"] extends true ? SchemaTypeInner<T> : SchemaTypeInner<T> | undefined | null;
-export type SchemaMapType<T extends Record<string, DataTypeSchema>> = SchemaType<{
-    type: "object";
-    required: true;
-    properties: T;
-}>;
-export {};

package/lib/cjs/logger.d.ts

@@ -1,2 +0,0 @@
-declare const logger: Console;
-export default logger;

package/lib/dts/definitions/data-type-schema.d.ts

@@ -1,42 +0,0 @@
-import type { MakeNullablePropertyOptional } from "../utils/nullable";
-import { OrderedRecord } from "../utils/ordered-map";
-import type { DataType } from "./data-type";
-export declare function schemaToDataType(dataType: {
-    [name: string]: DataTypeSchema;
-}): OrderedRecord<DataType>;
-export type DataTypeSchema = DataTypeSchemaString | DataTypeSchemaNumber | DataTypeSchemaBoolean | DataTypeSchemaObject | DataTypeSchemaArray;
-export interface DataTypeSchemaBase {
-    description?: string;
-    required?: boolean;
-}
-export interface DataTypeSchemaString extends DataTypeSchemaBase {
-    type: "string";
-}
-export interface DataTypeSchemaNumber extends DataTypeSchemaBase {
-    type: "number";
-}
-export interface DataTypeSchemaBoolean extends DataTypeSchemaBase {
-    type: "boolean";
-}
-export interface DataTypeSchemaObject extends DataTypeSchemaBase {
-    type: "object";
-    properties?: {
-        [key: string]: DataTypeSchema;
-    };
-}
-export interface DataTypeSchemaArray extends DataTypeSchemaBase {
-    type: "array";
-    items?: DataTypeSchema;
-}
-type SchemaTypeInner<T extends DataTypeSchema> = T extends DataTypeSchemaString ? string : T extends DataTypeSchemaNumber ? number : T extends DataTypeSchemaBoolean ? boolean : T extends DataTypeSchemaObject ? MakeNullablePropertyOptional<{
-    [K in keyof T["properties"]]: SchemaType<NonNullable<T["properties"]>[K]>;
-}> : T extends DataTypeSchemaArray ? T["items"] extends null | undefined ? SchemaType<{
-    type: "object";
-}>[] : SchemaType<NonNullable<T["items"]>>[] : never;
-export type SchemaType<T extends DataTypeSchema> = T["required"] extends true ? SchemaTypeInner<T> : SchemaTypeInner<T> | undefined | null;
-export type SchemaMapType<T extends Record<string, DataTypeSchema>> = SchemaType<{
-    type: "object";
-    required: true;
-    properties: T;
-}>;
-export {};

package/lib/dts/logger.d.ts

@@ -1,2 +0,0 @@
-declare const logger: Console;
-export default logger;

package/lib/esm/definitions/data-type-schema.d.ts

@@ -1,42 +0,0 @@
-import type { MakeNullablePropertyOptional } from "../utils/nullable";
-import { OrderedRecord } from "../utils/ordered-map";
-import type { DataType } from "./data-type";
-export declare function schemaToDataType(dataType: {
-    [name: string]: DataTypeSchema;
-}): OrderedRecord<DataType>;
-export type DataTypeSchema = DataTypeSchemaString | DataTypeSchemaNumber | DataTypeSchemaBoolean | DataTypeSchemaObject | DataTypeSchemaArray;
-export interface DataTypeSchemaBase {
-    description?: string;
-    required?: boolean;
-}
-export interface DataTypeSchemaString extends DataTypeSchemaBase {
-    type: "string";
-}
-export interface DataTypeSchemaNumber extends DataTypeSchemaBase {
-    type: "number";
-}
-export interface DataTypeSchemaBoolean extends DataTypeSchemaBase {
-    type: "boolean";
-}
-export interface DataTypeSchemaObject extends DataTypeSchemaBase {
-    type: "object";
-    properties?: {
-        [key: string]: DataTypeSchema;
-    };
-}
-export interface DataTypeSchemaArray extends DataTypeSchemaBase {
-    type: "array";
-    items?: DataTypeSchema;
-}
-type SchemaTypeInner<T extends DataTypeSchema> = T extends DataTypeSchemaString ? string : T extends DataTypeSchemaNumber ? number : T extends DataTypeSchemaBoolean ? boolean : T extends DataTypeSchemaObject ? MakeNullablePropertyOptional<{
-    [K in keyof T["properties"]]: SchemaType<NonNullable<T["properties"]>[K]>;
-}> : T extends DataTypeSchemaArray ? T["items"] extends null | undefined ? SchemaType<{
-    type: "object";
-}>[] : SchemaType<NonNullable<T["items"]>>[] : never;
-export type SchemaType<T extends DataTypeSchema> = T["required"] extends true ? SchemaTypeInner<T> : SchemaTypeInner<T> | undefined | null;
-export type SchemaMapType<T extends Record<string, DataTypeSchema>> = SchemaType<{
-    type: "object";
-    required: true;
-    properties: T;
-}>;
-export {};

package/lib/esm/logger.d.ts

@@ -1,2 +0,0 @@
-declare const logger: Console;
-export default logger;

package/lib/esm/logger.js

@@ -1,2 +0,0 @@
-const logger = console;
-export default logger;