orchajs 0.20.2 → 0.21.0

package/dist/storage/browser-indexeddb.js

@@ -1,25 +1,108 @@
-/**
- * Future browser storage strategy.
- *
- * It will persist the same ordered SessionEvent records used by the JSONL
- * strategy in IndexedDB. Import and export will preserve the canonical JSONL
- * representation so a session can move between browser, Node, and remote
- * stores without changing the runtime or replay engine.
- *
- * Required before implementation:
- * - transactional sequence allocation;
- * - multi-tab writer coordination;
- * - quota and eviction handling;
- * - schema migrations and JSONL import/export.
- */
+const DATABASE_VERSION = 1;
+const EVENT_STORE = "events";
 export class BrowserIndexedDbSessionStore {
-    async read(_sessionId) {
-        throw new Error("Browser IndexedDB session storage is not implemented yet.");
+    #databaseName;
+    #namespace;
+    #listeners = new Map();
+    #allListeners = new Set();
+    constructor(namespace, databaseName = "orchajs") {
+        this.#namespace = namespace;
+        this.#databaseName = databaseName;
     }
-    async append(_sessionId, _events) {
-        throw new Error("Browser IndexedDB session storage is not implemented yet.");
+    async read(sessionId) {
+        const database = await this.#open();
+        const transaction = database.transaction(EVENT_STORE, "readonly");
+        const index = transaction.objectStore(EVENT_STORE).index("session");
+        const records = await request(index.getAll(IDBKeyRange.only([this.#namespace, sessionId])));
+        await transactionComplete(transaction);
+        return records
+            .sort((left, right) => left.sequence - right.sequence)
+            .map((record) => record.event);
+    }
+    async append(sessionId, events) {
+        if (events.length === 0) {
+            return;
+        }
+        const database = await this.#open();
+        const transaction = database.transaction(EVENT_STORE, "readwrite");
+        const store = transaction.objectStore(EVENT_STORE);
+        for (const event of events) {
+            store.add({
+                id: eventId(this.#namespace, sessionId, event.sequence),
+                namespace: this.#namespace,
+                sessionId,
+                sequence: event.sequence,
+                event,
+            });
+        }
+        await transactionComplete(transaction);
+        this.#listeners.get(sessionId)?.forEach((listener) => listener(events));
+        this.#allListeners.forEach((listener) => listener(sessionId, events));
     }
     async listSessionIds() {
-        throw new Error("Browser IndexedDB session storage is not implemented yet.");
+        const database = await this.#open();
+        const transaction = database.transaction(EVENT_STORE, "readonly");
+        const index = transaction.objectStore(EVENT_STORE).index("namespace");
+        const records = await request(index.getAll(IDBKeyRange.only(this.#namespace)));
+        await transactionComplete(transaction);
+        return [...new Set(records.map((record) => record.sessionId))].sort();
+    }
+    subscribe(sessionId, listener) {
+        const listeners = this.#listeners.get(sessionId) ?? new Set();
+        listeners.add(listener);
+        this.#listeners.set(sessionId, listeners);
+        return () => {
+            listeners.delete(listener);
+            if (listeners.size === 0) {
+                this.#listeners.delete(sessionId);
+            }
+        };
+    }
+    subscribeAll(listener) {
+        this.#allListeners.add(listener);
+        return () => this.#allListeners.delete(listener);
+    }
+    async describeLocation(sessionId) {
+        return `indexeddb://${this.#databaseName}/${this.#namespace}/${sessionId}`;
     }
+    #open() {
+        if (typeof indexedDB === "undefined") {
+            throw new Error("IndexedDB is unavailable in this runtime.");
+        }
+        return new Promise((resolve, reject) => {
+            const openRequest = indexedDB.open(this.#databaseName, DATABASE_VERSION);
+            openRequest.onupgradeneeded = () => {
+                const database = openRequest.result;
+                if (database.objectStoreNames.contains(EVENT_STORE)) {
+                    return;
+                }
+                const store = database.createObjectStore(EVENT_STORE, {
+                    keyPath: "id",
+                });
+                store.createIndex("session", ["namespace", "sessionId"]);
+                store.createIndex("namespace", "namespace");
+            };
+            openRequest.onsuccess = () => resolve(openRequest.result);
+            openRequest.onerror = () => reject(openRequest.error);
+            openRequest.onblocked = () => reject(new Error("Opening the Orcha IndexedDB database was blocked."));
+        });
+    }
+}
+function eventId(namespace, sessionId, sequence) {
+    return `${namespace}\u0000${sessionId}\u0000${sequence
+        .toString()
+        .padStart(12, "0")}`;
+}
+function request(value) {
+    return new Promise((resolve, reject) => {
+        value.onsuccess = () => resolve(value.result);
+        value.onerror = () => reject(value.error);
+    });
+}
+function transactionComplete(transaction) {
+    return new Promise((resolve, reject) => {
+        transaction.oncomplete = () => resolve();
+        transaction.onerror = () => reject(transaction.error);
+        transaction.onabort = () => reject(transaction.error ?? new Error("IndexedDB transaction aborted."));
+    });
 }

package/dist/storage/react-native-jsonl.d.ts

@@ -1,20 +1,11 @@
 import type { SessionEvent, SessionStore } from "../types.js";
-/**
- * Future React Native storage strategy.
- *
- * It will store one JSONL event stream per session inside the application's
- * private documents directory. The implementation must not assume Node's
- * `fs` module: Expo FileSystem and bare React Native filesystem bindings need
- * a small host adapter while retaining the exact SessionStore contract.
- *
- * Required before implementation:
- * - Expo and bare React Native filesystem adapters;
- * - atomic append/recovery behavior on iOS and Android;
- * - app lifecycle interruption handling;
- * - JSONL import/export conformance tests.
- */
 export declare class ReactNativeJsonlSessionStore implements SessionStore {
-    read(_sessionId: string): Promise<SessionEvent[]>;
-    append(_sessionId: string, _events: SessionEvent[]): Promise<void>;
+    #private;
+    constructor(namespace: string);
+    read(sessionId: string): Promise<SessionEvent[]>;
+    append(sessionId: string, events: SessionEvent[]): Promise<void>;
     listSessionIds(): Promise<string[]>;
+    subscribe(sessionId: string, listener: (events: SessionEvent[]) => void): () => void;
+    subscribeAll(listener: (sessionId: string, events: SessionEvent[]) => void): () => void;
+    describeLocation(sessionId: string): Promise<string>;
 }

package/dist/storage/react-native-jsonl.js

@@ -1,25 +1,71 @@
-/**
- * Future React Native storage strategy.
- *
- * It will store one JSONL event stream per session inside the application's
- * private documents directory. The implementation must not assume Node's
- * `fs` module: Expo FileSystem and bare React Native filesystem bindings need
- * a small host adapter while retaining the exact SessionStore contract.
- *
- * Required before implementation:
- * - Expo and bare React Native filesystem adapters;
- * - atomic append/recovery behavior on iOS and Android;
- * - app lifecycle interruption handling;
- * - JSONL import/export conformance tests.
- */
+import AsyncStorage from "@react-native-async-storage/async-storage";
+const writes = new Map();
 export class ReactNativeJsonlSessionStore {
-    async read(_sessionId) {
-        throw new Error("React Native JSONL session storage is not implemented yet.");
+    #namespace;
+    #listeners = new Map();
+    #allListeners = new Set();
+    constructor(namespace) {
+        this.#namespace = namespace;
     }
-    async append(_sessionId, _events) {
-        throw new Error("React Native JSONL session storage is not implemented yet.");
+    async read(sessionId) {
+        const contents = await AsyncStorage.getItem(this.#key(sessionId));
+        if (!contents) {
+            return [];
+        }
+        return contents
+            .split("\n")
+            .filter(Boolean)
+            .map((line) => JSON.parse(line));
+    }
+    async append(sessionId, events) {
+        if (events.length === 0) {
+            return;
+        }
+        const key = this.#key(sessionId);
+        const previous = writes.get(key) ?? Promise.resolve();
+        const write = previous.then(async () => {
+            const existing = await AsyncStorage.getItem(key);
+            const appended = events.map((event) => JSON.stringify(event)).join("\n");
+            await AsyncStorage.setItem(key, `${existing ? `${existing.replace(/\n*$/, "")}\n` : ""}${appended}\n`);
+        });
+        writes.set(key, write);
+        try {
+            await write;
+        }
+        finally {
+            if (writes.get(key) === write) {
+                writes.delete(key);
+            }
+        }
+        this.#listeners.get(sessionId)?.forEach((listener) => listener(events));
+        this.#allListeners.forEach((listener) => listener(sessionId, events));
     }
     async listSessionIds() {
-        throw new Error("React Native JSONL session storage is not implemented yet.");
+        const prefix = `@orchajs:${this.#namespace}:`;
+        return (await AsyncStorage.getAllKeys())
+            .filter((key) => key.startsWith(prefix))
+            .map((key) => key.slice(prefix.length))
+            .sort();
+    }
+    subscribe(sessionId, listener) {
+        const listeners = this.#listeners.get(sessionId) ?? new Set();
+        listeners.add(listener);
+        this.#listeners.set(sessionId, listeners);
+        return () => {
+            listeners.delete(listener);
+            if (listeners.size === 0) {
+                this.#listeners.delete(sessionId);
+            }
+        };
+    }
+    subscribeAll(listener) {
+        this.#allListeners.add(listener);
+        return () => this.#allListeners.delete(listener);
+    }
+    async describeLocation(sessionId) {
+        return `async-storage://${this.#key(sessionId)}`;
+    }
+    #key(sessionId) {
+        return `@orchajs:${this.#namespace}:${sessionId}`;
     }
 }

package/dist/types.d.ts

@@ -43,7 +43,7 @@ export interface ProjectConfiguration {
     providers: ResolvedProviderConfigurations;
     actions?: LocalActionRuntimeConfiguration;
     storage?: {
-        strategy?: "node-jsonl" | "sqlite";
+        strategy?: "node-jsonl" | "sqlite" | "indexeddb" | "react-native";
         directory?: string;
     };
 }
@@ -54,6 +54,8 @@ export type AgentRegistration = string | {
 export interface OrchaInitConfiguration {
     providers: ProviderInitConfigurations;
     agents: Record<string, AgentRegistration>;
+    /** Precompiled registry used by browser, React Native, and custom runtimes. */
+    bundle?: CompiledBundle;
     amarsia?: {
         key: string;
         endpoint?: string;

package/dist-cjs/browser.js

@@ -0,0 +1,48 @@
+"use strict"; const __orchaImportMetaUrl = require("url").pathToFileURL(__filename).href;
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var browser_exports = {};
+__export(browser_exports, {
+  orcha: () => orcha
+});
+module.exports = __toCommonJS(browser_exports);
+var import_browser = require("./providers/browser.js");
+var import_execute = require("./runtime/actions/execute.js");
+var import_create_orcha = require("./runtime/create-orcha.js");
+var import_platform_browser = require("./runtime/platform-browser.js");
+__reExport(browser_exports, require("./runtime-entry.js"), module.exports);
+(0, import_execute.setNativeRuntimeLoader)(async () => {
+  const modulePath = "./runtime/actions/browser-native.js";
+  return import(modulePath);
+});
+const orcha = (0, import_create_orcha.createOrcha)(
+  () => {
+    throw new Error(
+      "The browser runtime requires a precompiled Orcha bundle. Configure the Orcha integration for your application bundler."
+    );
+  },
+  import_browser.generateBrowserProviderResponse,
+  import_platform_browser.browserRuntimePlatform
+);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  orcha,
+  ...require("./runtime-entry.js")
+});

package/dist-cjs/cli-agents-template.js

@@ -52,6 +52,28 @@ credentials. \`dev\` and \`build\` are offline. Sessions use JSONL by default
 under \`.orcha/sessions/<agentName>/\`; opt-in SQLite stores all agents in
 \`.orcha/sessions/orcha-sqlite.db\`.
 
+## Production deployment
+
+\`orcha build\` writes \`.orcha/dist/bundle.js\` for bundler integrations and
+\`.orcha/dist/manifest.json\` for unbundled production runtimes. If deployment
+uses plain \`tsc\`, \`serverless-plugin-typescript\`, or another packager that
+does not use \`orchajs/esbuild\`, explicitly include \`.orcha/dist/**\` in the
+deployment artifact. AWS Lambda loads the manifest automatically; other
+unbundled environments require \`NODE_ENV=production\` or
+\`ORCHA_USE_BUILD=1\`.
+
+For Serverless Framework manual builds:
+
+\`\`\`yaml
+package:
+  patterns:
+    - ".orcha/dist/**"
+\`\`\`
+
+Do not assume that a successful \`orcha build\` means the generated files were
+copied by a later packaging tool. Inspect the final ZIP or container image and
+confirm that \`.orcha/dist/manifest.json\` is present.
+
 ## Registry
 
 \`orcha/index.ts\` initializes providers and explicitly registers agents:

package/dist-cjs/compiler/build-project.js

@@ -28,9 +28,21 @@ var import_path = require("path");
 var import_url = require("url");
 var import_esbuild = require("esbuild");
 var import_orcha = require("../orcha.js");
+var import_compiler_hook = require("../runtime/compiler-hook.js");
+var import_compile = require("./compile.js");
 var import_catalog = require("../providers/catalog.js");
+let registryImportSequence = 0;
 async function buildProject(options = {}) {
   const projectRoot = (0, import_path.resolve)(options.projectRoot ?? process.cwd());
+  const target = options.target ?? "node";
+  (0, import_compiler_hook.setRegistryCompiler)(
+    (configuration, compilerProjectRoot) => (0, import_compile.compileRegistry)(
+      configuration.agents,
+      (0, import_path.resolve)(compilerProjectRoot, "orcha"),
+      configuration.actions?.runtime ?? "native",
+      target
+    )
+  );
   const registryPath = (0, import_path.resolve)(projectRoot, "orcha/index.ts");
   if (!(0, import_fs.existsSync)(registryPath)) {
     throw new Error('Missing "orcha/index.ts". Run "orcha init" first.');
@@ -41,7 +53,10 @@ async function buildProject(options = {}) {
     temporaryDirectory,
     "production-entry.mjs"
   );
-  const outputPath = (0, import_path.resolve)(projectRoot, ".orcha/dist/bundle.js");
+  const outputPath = (0, import_path.resolve)(
+    projectRoot,
+    `.orcha/dist/${bundleFileName(target)}`
+  );
   const manifestPath = (0, import_path.resolve)(
     projectRoot,
     ".orcha/dist/manifest.json"
@@ -64,7 +79,7 @@ async function buildProject(options = {}) {
     process.env.ORCHA_COMPILING = "1";
     process.env.ORCHA_PROJECT_ROOT = projectRoot;
     try {
-      await import(`${(0, import_url.pathToFileURL)(registryBundlePath).href}?time=${Date.now()}`);
+      await import(`${(0, import_url.pathToFileURL)(registryBundlePath).href}?build=${Date.now()}-${registryImportSequence++}`);
     } finally {
       if (previousCompiling === void 0) {
         delete process.env.ORCHA_COMPILING;
@@ -78,15 +93,30 @@ async function buildProject(options = {}) {
       }
     }
     const compiledBundle = import_orcha.orcha.getCompiledBundle();
+    if (target !== "node" && compiledBundle.actionRuntime === "sandbox") {
+      throw new Error(
+        `The ${target} target supports precompiled native actions only. Set actions.runtime to "native".`
+      );
+    }
     const runtimeFactoryPath = (0, import_path.resolve)(
       (0, import_path.dirname)((0, import_url.fileURLToPath)(__orchaImportMetaUrl)),
       "../runtime/create-orcha.js"
     ).replaceAll("\\", "/");
+    const runtimePlatformPath = (0, import_path.resolve)(
+      (0, import_path.dirname)((0, import_url.fileURLToPath)(__orchaImportMetaUrl)),
+      `../runtime/platform-${target}.js`
+    ).replaceAll("\\", "/");
+    const runtimeEntryPath = (0, import_path.resolve)(
+      (0, import_path.dirname)((0, import_url.fileURLToPath)(__orchaImportMetaUrl)),
+      "../runtime-entry.js"
+    ).replaceAll("\\", "/");
     const providerDispatcherPath = (0, import_path.resolve)(
       (0, import_path.dirname)((0, import_url.fileURLToPath)(__orchaImportMetaUrl)),
       "../providers/dispatcher.js"
     ).replaceAll("\\", "/");
     const sandboxRuntimeSource = compiledBundle.actionRuntime === "sandbox" ? createSandboxRuntimeSource() : "";
+    const platformActionRuntimeSource = createPlatformActionRuntimeSource(target);
+    const nodeStorageExports = target === "node" ? createNodeStorageExports() : "";
     const includedProviders = [
       ...new Set(
         allCompiledAgents(compiledBundle.agents).flatMap(
@@ -97,18 +127,22 @@ async function buildProject(options = {}) {
         )
       )
     ];
-    const providerRuntimeSource = createProviderRuntimeSource(includedProviders);
+    const providerRuntimeSource = createProviderRuntimeSource(includedProviders, target);
     const needsNodeRequire = compiledBundle.actionRuntime === "sandbox" || includedProviders.includes("vertexai") || includedProviders.includes("bedrock");
     await (0, import_promises.writeFile)(
       productionEntryPath,
       [
         `import { createOrcha } from ${JSON.stringify(runtimeFactoryPath)};`,
+        `import { ${runtimePlatformExport(target)} as runtimePlatform } from ${JSON.stringify(runtimePlatformPath)};`,
         `import { createProviderResponseGenerator } from ${JSON.stringify(providerDispatcherPath)};`,
+        `export * from ${JSON.stringify(runtimeEntryPath)};`,
+        nodeStorageExports,
         providerRuntimeSource,
+        platformActionRuntimeSource,
         sandboxRuntimeSource,
         `const compiledBundle = ${JSON.stringify(compiledBundle)};`,
         "const generateProviderResponse = createProviderResponseGenerator(includedProviders);",
-        "export const orcha = createOrcha(() => compiledBundle, generateProviderResponse);",
+        "export const orcha = createOrcha(() => compiledBundle, generateProviderResponse, runtimePlatform);",
         "export default orcha;",
         ""
       ].join("\n"),
@@ -119,8 +153,8 @@ async function buildProject(options = {}) {
       outfile: outputPath,
       bundle: true,
       format: "esm",
-      platform: "node",
-      target: "node18",
+      platform: target === "node" ? "node" : "browser",
+      target: target === "node" ? "node18" : target === "browser" ? ["chrome110", "firefox110", "safari16"] : "es2022",
       minify: true,
       legalComments: "none",
       define: {
@@ -128,7 +162,7 @@ async function buildProject(options = {}) {
           compiledBundle.actionRuntime === "sandbox" ? "1" : "0"
         )
       },
-      ...needsNodeRequire ? {
+      ...needsNodeRequire && target === "node" ? {
         banner: {
           js: [
             'import { createRequire as __orchaCreateRequire } from "module";',
@@ -136,6 +170,11 @@ async function buildProject(options = {}) {
           ].join("\n")
         }
       } : {},
+      ...target === "react-native" ? {
+        external: [
+          "@react-native-async-storage/async-storage"
+        ]
+      } : {},
       logLevel: "silent"
     });
     await (0, import_promises.writeFile)(
@@ -152,6 +191,18 @@ async function buildProject(options = {}) {
     });
   }
 }
+function bundleFileName(target) {
+  return target === "node" ? "bundle.js" : `bundle.${target}.js`;
+}
+function runtimePlatformExport(target) {
+  if (target === "browser") {
+    return "browserRuntimePlatform";
+  }
+  if (target === "react-native") {
+    return "reactNativeRuntimePlatform";
+  }
+  return "nodeRuntimePlatform";
+}
 function createSandboxRuntimeSource() {
   const runtimeDirectory = (0, import_path.dirname)((0, import_url.fileURLToPath)(__orchaImportMetaUrl));
   const executePath = (0, import_path.resolve)(
@@ -169,13 +220,46 @@ function createSandboxRuntimeSource() {
     ""
   ].join("\n");
 }
+function createPlatformActionRuntimeSource(target) {
+  const runtimeDirectory = (0, import_path.dirname)((0, import_url.fileURLToPath)(__orchaImportMetaUrl));
+  const executePath = (0, import_path.resolve)(
+    runtimeDirectory,
+    "../runtime/actions/execute.js"
+  ).replaceAll("\\", "/");
+  const nativePath = (0, import_path.resolve)(
+    runtimeDirectory,
+    target === "node" ? "../runtime/actions/native.js" : "../runtime/actions/browser-native.js"
+  ).replaceAll("\\", "/");
+  return [
+    `import { setNativeRuntimeLoader } from ${JSON.stringify(executePath)};`,
+    `import { executeNativeAction } from ${JSON.stringify(nativePath)};`,
+    "setNativeRuntimeLoader(async () => ({ executeNativeAction }));",
+    ""
+  ].join("\n");
+}
+function createNodeStorageExports() {
+  const sourceRoot = (0, import_path.dirname)((0, import_url.fileURLToPath)(__orchaImportMetaUrl));
+  const jsonlPath = (0, import_path.resolve)(
+    sourceRoot,
+    "../storage/node-jsonl.js"
+  ).replaceAll("\\", "/");
+  const sqlitePath = (0, import_path.resolve)(
+    sourceRoot,
+    "../storage/node-sqlite.js"
+  ).replaceAll("\\", "/");
+  return [
+    `export { NodeJsonlSessionStore } from ${JSON.stringify(jsonlPath)};`,
+    `export { NodeSqliteSessionStore } from ${JSON.stringify(sqlitePath)};`,
+    ""
+  ].join("\n");
+}
 function allCompiledAgents(agents) {
   return Object.values(agents).flatMap((agent) => [
     agent,
     ...Object.values(agent.subagents ?? {})
   ]);
 }
-function createProviderRuntimeSource(providerNames) {
+function createProviderRuntimeSource(providerNames, target) {
   const providersDirectory = (0, import_path.resolve)(
     (0, import_path.dirname)((0, import_url.fileURLToPath)(__orchaImportMetaUrl)),
     "../providers"
@@ -186,6 +270,11 @@ function createProviderRuntimeSource(providerNames) {
     if (!(0, import_catalog.isBuiltInProvider)(name)) {
       throw new Error(`Provider "${name}" is not built in.`);
     }
+    if (target !== "node" && (name === "bedrock" || name === "vertexai")) {
+      throw new Error(
+        `Provider "${name}" is not available for the ${target} target.`
+      );
+    }
     const descriptor = import_catalog.builtInProviderCatalog[name];
     const localName = `provider${index}`;
     imports.push(

package/dist-cjs/compiler/compile.js

@@ -28,7 +28,7 @@ var import_fs = require("fs");
 var import_path = require("path");
 var import_esbuild = require("esbuild");
 var import_catalog = require("../providers/catalog.js");
-function compileRegistry(registrations, registryRoot, actionRuntime = "native") {
+function compileRegistry(registrations, registryRoot, actionRuntime = "native", target = "node") {
   if (!registrations || typeof registrations !== "object" || Array.isArray(registrations)) {
     throw new TypeError(
       'orcha.init() requires an "agents" object of registered folder paths.'
@@ -51,14 +51,16 @@ function compileRegistry(registrations, registryRoot, actionRuntime = "native")
         subagentKey,
         registeredPath,
         registryRoot,
-        actionRuntime
+        actionRuntime,
+        target
       );
     }
     const parent = compileAgent(
       key,
       normalized.path,
       registryRoot,
-      actionRuntime
+      actionRuntime,
+      target
     );
     agents[key] = Object.freeze({
       ...parent,
@@ -108,7 +110,7 @@ function normalizeAgentRegistration(key, registration) {
     subagents: registration.subagents ?? {}
   };
 }
-function compileAgent(key, registeredPath, registryRoot, actionRuntime) {
+function compileAgent(key, registeredPath, registryRoot, actionRuntime, target) {
   const name = key;
   const sourceDirectory = (0, import_path.resolve)(registryRoot, registeredPath);
   const configPath = (0, import_path.resolve)(sourceDirectory, "index.json");
@@ -195,14 +197,19 @@ function compileAgent(key, registeredPath, registryRoot, actionRuntime) {
     reasoningLevel: configuration.reasoningLevel,
     outputType: configuration.outputType ?? "text",
     outputSchema: configuration.outputSchema,
-    actions: compileActions(name, sourceDirectory, actionRuntime),
+    actions: compileActions(
+      name,
+      sourceDirectory,
+      actionRuntime,
+      target
+    ),
     skills: compileSkills(name, sourceDirectory),
     evaluations: compileEvaluations(name, sourceDirectory),
     subagentPolicy: configuration.subagents ? Object.freeze({ ...configuration.subagents }) : void 0,
     subagents: Object.freeze({})
   });
 }
-function compileActions(agentName, sourceDirectory, actionRuntime) {
+function compileActions(agentName, sourceDirectory, actionRuntime, target) {
   const actionsDirectory = (0, import_path.resolve)(sourceDirectory, "actions");
   if (!(0, import_fs.existsSync)(actionsDirectory)) {
     return {};
@@ -306,7 +313,8 @@ function compileActions(agentName, sourceDirectory, actionRuntime) {
       agentName,
       entry.name,
       actionsDirectory,
-      actionRuntime
+      actionRuntime,
+      target
     ) : void 0;
     actions[configuration.name] = Object.freeze({
       ...configuration,
@@ -498,7 +506,7 @@ function validateEvaluationConfiguration(agentName, registrationName, configurat
     names.add(metric.name);
   }
 }
-function compileLocalAction(agentName, directoryName, actionsDirectory, actionRuntime) {
+function compileLocalAction(agentName, directoryName, actionsDirectory, actionRuntime, target) {
   const entryPath = (0, import_path.resolve)(actionsDirectory, directoryName, "index.js");
   if (!(0, import_fs.existsSync)(entryPath)) {
     throw new Error(
@@ -513,7 +521,7 @@ function compileLocalAction(agentName, directoryName, actionsDirectory, actionRu
       write: false,
       format: "iife",
       globalName: "__orchaActionModule",
-      platform: actionRuntime === "native" ? "node" : "neutral",
+      platform: actionRuntime === "native" && target === "node" ? "node" : "browser",
       target: "es2022",
       logLevel: "silent"
     });