@aigne/core 1.0.3 → 1.0.4

package/lib/esm/runtime.js

@@ -0,0 +1,141 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var Runtime_1;
+import { produce } from "immer";
+import { merge } from "lodash";
+import { nanoid } from "nanoid";
+import { container, injectable } from "tsyringe";
+import { TYPES } from "./constants";
+import { FunctionAgent } from "./function-agent";
+import { LLMAgent } from "./llm-agent";
+import { LLMDecisionAgent } from "./llm-decision-agent";
+import { LocalFunctionAgent } from "./local-function-agent";
+import { OpenAPIAgent } from "./open-api-agent";
+import { PipelineAgent } from "./pipeline-agent";
+import { Runnable } from "./runnable";
+import { OrderedRecord } from "./utils/ordered-map";
+let Runtime = Runtime_1 = class Runtime {
+    constructor(options = {}) {
+        // support copy inner from a existing runtime, but not expose to public
+        const inner = options.inner;
+        if (inner instanceof RuntimeInner)
+            this.inner = inner;
+        else
+            this.inner = new RuntimeInner(options);
+        this.container = this.inner.container.createChildContainer();
+        this.container.register(TYPES.context, { useValue: this });
+        this.config = options.config || { ...this.inner.config };
+        this.state = options.state || { ...this.inner.state };
+    }
+    inner;
+    get options() {
+        return this.inner.options;
+    }
+    get id() {
+        return this.inner.id;
+    }
+    get name() {
+        return this.inner.name;
+    }
+    config;
+    state;
+    agents = new Proxy({}, { get: (_, prop) => this.resolveSync(prop.toString()) });
+    container;
+    setup(config) {
+        this.config = produce(this.config, (draft) => {
+            merge(draft, config);
+        });
+    }
+    register(...runnables) {
+        for (const runnable of runnables) {
+            OrderedRecord.pushOrUpdate(this.inner.runnableDefinitions, runnable instanceof Runnable ? runnable.definition : runnable);
+        }
+    }
+    resolveSync(idOrRunnable) {
+        const runnableId = typeof idOrRunnable === "string" ? idOrRunnable : idOrRunnable.id;
+        // Find runnable definition by id or name
+        let definition = this.inner.runnableDefinitions[runnableId] ??
+            OrderedRecord.find(this.inner.runnableDefinitions, (def) => def.name === runnableId);
+        if (!definition) {
+            // extract definition from runnable
+            if (idOrRunnable instanceof Runnable)
+                definition = idOrRunnable.definition;
+            // directly use runnable as definition
+            else if (typeof idOrRunnable === "object")
+                definition = idOrRunnable;
+        }
+        if (definition) {
+            const childContainer = this.container
+                .createChildContainer()
+                .register(TYPES.definition, { useValue: definition });
+            const result = childContainer.resolve(definition.type);
+            childContainer.dispose();
+            return result;
+        }
+        throw new Error(`Runnable not found: ${idOrRunnable}`);
+    }
+    async resolve(id) {
+        return this.resolveSync(id);
+    }
+    resolveDependency(token) {
+        return this.container.resolve(token);
+    }
+    copy(options) {
+        const clone = new Runtime_1({
+            ...options,
+            // Copy inner runtime
+            ...{ inner: this.inner },
+        });
+        return clone;
+    }
+};
+Runtime = Runtime_1 = __decorate([
+    injectable(),
+    __metadata("design:paramtypes", [Object])
+], Runtime);
+export { Runtime };
+class RuntimeInner {
+    options;
+    constructor(options) {
+        this.options = options;
+        this.name = options.name;
+        this.id = options.id || this.name || nanoid();
+        this.config = options.config || {};
+        this.state = options.state || {};
+        this.container.register("pipeline_agent", { useClass: PipelineAgent });
+        this.container.register("llm_agent", { useClass: LLMAgent });
+        this.container.register("function_agent", { useClass: FunctionAgent });
+        this.container.register("llm_decision_agent", {
+            useClass: LLMDecisionAgent,
+        });
+        this.container.register("local_function_agent", {
+            useClass: LocalFunctionAgent,
+        });
+        this.container.register("open_api_agent", { useClass: OpenAPIAgent });
+        if (options.functionRunner)
+            this.registerDependency(TYPES.functionRunner, options.functionRunner);
+        if (options.llmModel)
+            this.registerDependency(TYPES.llmModel, options.llmModel);
+    }
+    id;
+    name;
+    config;
+    state;
+    container = container.createChildContainer();
+    runnableDefinitions = OrderedRecord.fromArray([]);
+    registerDependency(token, dependency) {
+        if (typeof dependency === "function")
+            this.container.register(token, {
+                useClass: dependency,
+            });
+        else
+            this.container.register(token, { useValue: dependency });
+    }
+}

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

@@ -6,5 +6,6 @@ export * from "./nullable";
 export * from "./omit";
 export * from "./open-api-parameter";
 export * from "./ordered-map";
+export * from "./partial";
 export * from "./stream-utils";
 export * from "./union";

package/lib/esm/utils/index.js

@@ -6,5 +6,6 @@ export * from "./nullable";
 export * from "./omit";
 export * from "./open-api-parameter";
 export * from "./ordered-map";
+export * from "./partial";
 export * from "./stream-utils";
 export * from "./union";

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

@@ -0,0 +1,3 @@
+export type DeepPartial<T> = T extends object ? {
+    [P in keyof T]?: DeepPartial<T[P]>;
+} : T;

package/lib/esm/utils/partial.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aigne/core",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "description": "AIGNE core library",
   "publishConfig": {
     "access": "public"
@@ -31,12 +31,18 @@
     "tsyringe": "^4.8.0",
     "ufo": "^1.5.4"
   },
+  "peerDependencies": {
+    "@google/generative-ai": "^0.21.0",
+    "openai": "^4.79.1"
+  },
   "devDependencies": {
+    "@google/generative-ai": "^0.21.0",
     "@tsconfig/recommended": "^1.0.8",
     "@types/bun": "^1.1.17",
     "@types/lodash": "^4.17.14",
     "core-js": "^3.40.0",
     "npm-run-all": "^4.1.5",
+    "openai": "^4.79.1",
     "reflect-metadata": "^0.2.2",
     "rimraf": "^6.0.1",
     "typescript": "^5.7.3"