orchajs 0.20.3 → 0.22.0

package/dist/cli.js

@@ -24,8 +24,7 @@ try {
             await initializeProject(projectRoot);
             break;
         case "dev":
-            assertNoArguments(commandArguments, "dev");
-            await watchProject(projectRoot);
+            await watchProject(projectRoot, parseDevTargets(commandArguments));
             break;
         case "run":
             await runAgent(projectRoot, commandArguments);
@@ -43,9 +42,13 @@ try {
             await exportSession(projectRoot, commandArguments);
             break;
         case "build": {
-            assertNoArguments(commandArguments, "build");
+            const parsed = parseArguments(commandArguments, new Set(["--target"]), new Set());
+            if (parsed.positionals.length > 0) {
+                throw new Error("Usage: orcha build [--target node|browser|react-native]");
+            }
+            const target = parseBuildTarget(parsed.values.get("--target"));
             loadProjectEnvironment(projectRoot);
-            const outputPath = await buildProject({ projectRoot });
+            const outputPath = await buildProject({ projectRoot, target });
             console.log(`Built ${relative(projectRoot, outputPath)}`);
             break;
         }
@@ -112,11 +115,12 @@ async function initializeProject(projectRoot) {
     await ensureGitignore(projectRoot);
     console.log('\nRun "orcha dev" to validate changes or "orcha run exampleAgent --input \\"Hello\\"" to execute the agent.');
 }
-async function watchProject(projectRoot) {
+async function watchProject(projectRoot, targets) {
     const registryDirectory = resolve(projectRoot, "orcha");
     if (!existsSync(registryDirectory)) {
         throw new Error('Missing "orcha/". Run "orcha init" first.');
     }
+    loadProjectEnvironment(projectRoot);
     let validating = false;
     let validateAgain = false;
     let timer;
@@ -127,7 +131,9 @@ async function watchProject(projectRoot) {
         }
         validating = true;
         try {
-            await loadProject(projectRoot);
+            for (const target of targets) {
+                await buildProject({ projectRoot, target });
+            }
             const agents = Object.keys(orcha.getCompiledBundle().agents);
             console.log(`[orcha] valid — ${agents.length} agent${agents.length === 1 ? "" : "s"}: ${agents.join(", ") || "none"}`);
         }
@@ -143,7 +149,7 @@ async function watchProject(projectRoot) {
         }
     };
     await validate();
-    console.log("[orcha] watching orcha/**");
+    console.log(`[orcha] watching orcha/** for ${targets.join(", ")}`);
     const watcher = watch(registryDirectory, { ignoreInitial: true }).on("all", () => {
         clearTimeout(timer);
         timer = setTimeout(() => void validate(), 75);
@@ -344,6 +350,26 @@ function allAgentManifests(agents) {
     }
     return [...manifests.values()];
 }
+function parseDevTargets(arguments_) {
+    const parsed = parseArguments(arguments_, new Set(["--target"]), new Set());
+    if (parsed.positionals.length > 0) {
+        throw new Error("Usage: orcha dev [--target node|browser|react-native|all]");
+    }
+    const target = parsed.values.get("--target") ?? "node";
+    if (target === "all") {
+        return ["browser", "react-native", "node"];
+    }
+    return [parseBuildTarget(target)];
+}
+function parseBuildTarget(value) {
+    if (value === undefined ||
+        value === "node" ||
+        value === "browser" ||
+        value === "react-native") {
+        return value ?? "node";
+    }
+    throw new Error(`Unknown build target "${value}". Expected node, browser, or react-native.`);
+}
 function parseArguments(arguments_, valueOptions, flagOptions = new Set(["--json"])) {
     const parsed = {
         positionals: [],
@@ -605,13 +631,13 @@ function printUsage() {
         "",
         "Commands:",
         "  init                         Add Orcha to the current project",
-        "  dev                          Validate and watch orcha/**",
+        "  dev [--target <runtime>]     Build and watch orcha/**",
         "  run <agent> [options]        Execute or resume an agent",
         "  test [agent | agent/test]    Run agent tests",
         "  playground [options]         Open the local agent playground",
         "  migrate-storage --to <type>  Copy sessions between JSONL and SQLite",
         "  export-session <agent> <id>  Export one session as JSONL",
-        "  build                        Build the production Orcha bundle",
+        "  build [--target <runtime>]   Build for node, browser, or react-native",
         "",
         "Run and test support --json for machine-readable output.",
     ].join("\n"));

package/dist/compiler/build-project.d.ts

@@ -1,4 +1,5 @@
 export interface BuildProjectOptions {
     projectRoot?: string;
+    target?: "node" | "browser" | "react-native";
 }
 export declare function buildProject(options?: BuildProjectOptions): Promise<string>;

package/dist/compiler/build-project.js

@@ -4,9 +4,14 @@ import { dirname, resolve } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { build as bundleEntry } from "esbuild";
 import { orcha } from "../orcha.js";
+import { setRegistryCompiler } from "../runtime/compiler-hook.js";
+import { compileRegistry } from "./compile.js";
 import { builtInProviderCatalog, isBuiltInProvider, } from "../providers/catalog.js";
+let registryImportSequence = 0;
 export async function buildProject(options = {}) {
     const projectRoot = resolve(options.projectRoot ?? process.cwd());
+    const target = options.target ?? "node";
+    setRegistryCompiler((configuration, compilerProjectRoot) => compileRegistry(configuration.agents, resolve(compilerProjectRoot, "orcha"), configuration.actions?.runtime ?? "native", target));
     const registryPath = resolve(projectRoot, "orcha/index.ts");
     if (!existsSync(registryPath)) {
         throw new Error('Missing "orcha/index.ts". Run "orcha init" first.');
@@ -14,7 +19,7 @@ export async function buildProject(options = {}) {
     const temporaryDirectory = resolve(projectRoot, ".orcha/.build");
     const registryBundlePath = resolve(temporaryDirectory, "registry.mjs");
     const productionEntryPath = resolve(temporaryDirectory, "production-entry.mjs");
-    const outputPath = resolve(projectRoot, ".orcha/dist/bundle.js");
+    const outputPath = resolve(projectRoot, `.orcha/dist/${bundleFileName(target)}`);
     const manifestPath = resolve(projectRoot, ".orcha/dist/manifest.json");
     await mkdir(temporaryDirectory, { recursive: true });
     await mkdir(dirname(outputPath), { recursive: true });
@@ -34,7 +39,7 @@ export async function buildProject(options = {}) {
         process.env.ORCHA_COMPILING = "1";
         process.env.ORCHA_PROJECT_ROOT = projectRoot;
         try {
-            await import(`${pathToFileURL(registryBundlePath).href}?time=${Date.now()}`);
+            await import(`${pathToFileURL(registryBundlePath).href}?build=${Date.now()}-${registryImportSequence++}`);
         }
         finally {
             if (previousCompiling === undefined) {
@@ -51,11 +56,19 @@ export async function buildProject(options = {}) {
             }
         }
         const compiledBundle = 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 = resolve(dirname(fileURLToPath(import.meta.url)), "../runtime/create-orcha.js").replaceAll("\\", "/");
+        const runtimePlatformPath = resolve(dirname(fileURLToPath(import.meta.url)), `../runtime/platform-${target}.js`).replaceAll("\\", "/");
+        const runtimeEntryPath = resolve(dirname(fileURLToPath(import.meta.url)), "../runtime-entry.js").replaceAll("\\", "/");
         const providerDispatcherPath = resolve(dirname(fileURLToPath(import.meta.url)), "../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((agent) => [
                 agent.provider,
@@ -64,18 +77,22 @@ export async function buildProject(options = {}) {
                     .map((evaluation) => evaluation.provider),
             ])),
         ];
-        const providerRuntimeSource = createProviderRuntimeSource(includedProviders);
+        const providerRuntimeSource = createProviderRuntimeSource(includedProviders, target);
         const needsNodeRequire = compiledBundle.actionRuntime === "sandbox" ||
             includedProviders.includes("vertexai") ||
             includedProviders.includes("bedrock");
         await 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"), "utf8");
@@ -84,14 +101,18 @@ export 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: {
                 "process.env.ORCHA_INCLUDE_SANDBOX": JSON.stringify(compiledBundle.actionRuntime === "sandbox" ? "1" : "0"),
             },
-            ...(needsNodeRequire
+            ...(needsNodeRequire && target === "node"
                 ? {
                     banner: {
                         js: [
@@ -101,6 +122,13 @@ export async function buildProject(options = {}) {
                     },
                 }
                 : {}),
+            ...(target === "react-native"
+                ? {
+                    external: [
+                        "@react-native-async-storage/async-storage",
+                    ],
+                }
+                : {}),
             logLevel: "silent",
         });
         await writeFile(manifestPath, `${JSON.stringify(compiledBundle)}\n`, "utf8");
@@ -113,6 +141,18 @@ export 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 = dirname(fileURLToPath(import.meta.url));
     const executePath = resolve(runtimeDirectory, "../runtime/actions/execute.js").replaceAll("\\", "/");
@@ -124,13 +164,36 @@ function createSandboxRuntimeSource() {
         "",
     ].join("\n");
 }
+function createPlatformActionRuntimeSource(target) {
+    const runtimeDirectory = dirname(fileURLToPath(import.meta.url));
+    const executePath = resolve(runtimeDirectory, "../runtime/actions/execute.js").replaceAll("\\", "/");
+    const nativePath = 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 = dirname(fileURLToPath(import.meta.url));
+    const jsonlPath = resolve(sourceRoot, "../storage/node-jsonl.js").replaceAll("\\", "/");
+    const sqlitePath = 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 = resolve(dirname(fileURLToPath(import.meta.url)), "../providers");
     const imports = [];
     const entries = [];
@@ -138,6 +201,10 @@ function createProviderRuntimeSource(providerNames) {
         if (!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 = builtInProviderCatalog[name];
         const localName = `provider${index}`;
         imports.push(`import { ${descriptor.exportName} as ${localName} } from ${JSON.stringify(resolve(providersDirectory, descriptor.moduleFile))};`);

package/dist/compiler/compile.d.ts

@@ -1,3 +1,3 @@
 import type { AgentRegistration, CompiledBundle } from "../types.js";
-export declare function compileRegistry(registrations: Record<string, AgentRegistration>, registryRoot: string, actionRuntime?: "native" | "sandbox"): CompiledBundle;
+export declare function compileRegistry(registrations: Record<string, AgentRegistration>, registryRoot: string, actionRuntime?: "native" | "sandbox", target?: "node" | "browser" | "react-native"): CompiledBundle;
 export declare function serializeBundle(bundle: CompiledBundle): string;

package/dist/compiler/compile.js

@@ -3,7 +3,7 @@ import { existsSync, readFileSync, readdirSync } from "node:fs";
 import { resolve } from "node:path";
 import { buildSync } from "esbuild";
 import { isBuiltInProvider } from "../providers/catalog.js";
-export function compileRegistry(registrations, registryRoot, actionRuntime = "native") {
+export function compileRegistry(registrations, registryRoot, actionRuntime = "native", target = "node") {
     if (!registrations ||
         typeof registrations !== "object" ||
         Array.isArray(registrations)) {
@@ -20,9 +20,9 @@ export function compileRegistry(registrations, registryRoot, actionRuntime = "na
             if (!subagentKey.trim()) {
                 throw new Error(`Agent "${key}" has an empty subagent name.`);
             }
-            subagents[subagentKey] = compileAgent(subagentKey, registeredPath, registryRoot, actionRuntime);
+            subagents[subagentKey] = compileAgent(subagentKey, registeredPath, registryRoot, actionRuntime, target);
         }
-        const parent = compileAgent(key, normalized.path, registryRoot, actionRuntime);
+        const parent = compileAgent(key, normalized.path, registryRoot, actionRuntime, target);
         agents[key] = Object.freeze({
             ...parent,
             subagentPolicy: Object.keys(subagents).length > 0
@@ -72,7 +72,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 = resolve(registryRoot, registeredPath);
     const configPath = resolve(sourceDirectory, "index.json");
@@ -148,7 +148,7 @@ 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
@@ -157,7 +157,7 @@ function compileAgent(key, registeredPath, registryRoot, actionRuntime) {
         subagents: Object.freeze({}),
     });
 }
-function compileActions(agentName, sourceDirectory, actionRuntime) {
+function compileActions(agentName, sourceDirectory, actionRuntime, target) {
     const actionsDirectory = resolve(sourceDirectory, "actions");
     if (!existsSync(actionsDirectory)) {
         return {};
@@ -229,7 +229,7 @@ function compileActions(agentName, sourceDirectory, actionRuntime) {
             throw new Error(`Agent "${agentName}" has duplicate action name "${configuration.name}".`);
         }
         const compiledSource = execution === "local"
-            ? compileLocalAction(agentName, entry.name, actionsDirectory, actionRuntime)
+            ? compileLocalAction(agentName, entry.name, actionsDirectory, actionRuntime, target)
             : undefined;
         actions[configuration.name] = Object.freeze({
             ...configuration,
@@ -413,7 +413,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 = resolve(actionsDirectory, directoryName, "index.js");
     if (!existsSync(entryPath)) {
         throw new Error(`Local action "${agentName}/${directoryName}" requires index.js.`);
@@ -426,7 +426,9 @@ 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",
         });

package/dist/errors.d.ts

@@ -9,3 +9,8 @@ export declare class OrchaError extends Error {
         cause?: unknown;
     });
 }
+export declare function describeProviderError(error: unknown): {
+    message: string;
+    details?: Record<string, unknown>;
+};
+export declare function isRetryableProviderConnectionError(error: unknown): boolean;

package/dist/errors.js

@@ -10,3 +10,105 @@ export class OrchaError extends Error {
         this.details = options.details;
     }
 }
+export function describeProviderError(error) {
+    const rootMessage = errorMessage(error);
+    const cause = deepestUsefulCause(error);
+    if (!cause) {
+        return { message: rootMessage };
+    }
+    const causeMessage = errorMessage(cause);
+    const causeCode = stringOrNumberField(cause, "code");
+    const syscall = stringField(cause, "syscall");
+    const hostname = stringField(cause, "hostname");
+    const explanation = causeMessage !== rootMessage
+        ? causeMessage
+        : causeCode
+            ? String(causeCode)
+            : undefined;
+    const details = {
+        ...(causeCode !== undefined ? { causeCode } : {}),
+        ...(syscall ? { syscall } : {}),
+        ...(hostname ? { hostname } : {}),
+        ...(explanation ? { causeMessage: explanation } : {}),
+    };
+    return {
+        message: explanation ? `${rootMessage}: ${explanation}` : rootMessage,
+        ...(Object.keys(details).length > 0 ? { details } : {}),
+    };
+}
+export function isRetryableProviderConnectionError(error) {
+    const retryableCodes = new Set([
+        "UND_ERR_CONNECT_TIMEOUT",
+        "EAI_AGAIN",
+        "ENETUNREACH",
+        "EHOSTUNREACH",
+        "ECONNREFUSED",
+    ]);
+    const pending = [error];
+    const visited = new Set();
+    while (pending.length > 0 && visited.size < 8) {
+        const current = pending.shift();
+        if (typeof current !== "object" ||
+            current === null ||
+            visited.has(current)) {
+            continue;
+        }
+        visited.add(current);
+        const record = current;
+        if (typeof record.code === "string" &&
+            retryableCodes.has(record.code)) {
+            return true;
+        }
+        if (record.cause !== undefined)
+            pending.push(record.cause);
+        if (Array.isArray(record.errors))
+            pending.push(...record.errors);
+    }
+    return false;
+}
+function deepestUsefulCause(error) {
+    let current = error;
+    let useful;
+    const visited = new Set();
+    for (let depth = 0; depth < 5; depth += 1) {
+        if ((typeof current !== "object" || current === null) ||
+            visited.has(current)) {
+            break;
+        }
+        visited.add(current);
+        const record = current;
+        const next = record.cause ??
+            (Array.isArray(record.errors) ? record.errors[0] : undefined);
+        if (next === undefined)
+            break;
+        useful = next;
+        current = next;
+    }
+    return useful;
+}
+function errorMessage(error) {
+    if (error instanceof Error && error.message.trim()) {
+        return error.message.trim();
+    }
+    if (typeof error === "object" && error !== null) {
+        const message = error.message;
+        if (typeof message === "string" && message.trim()) {
+            return message.trim();
+        }
+    }
+    return String(error);
+}
+function stringField(value, key) {
+    if (typeof value !== "object" || value === null)
+        return undefined;
+    const field = value[key];
+    return typeof field === "string" && field.trim() ? field : undefined;
+}
+function stringOrNumberField(value, key) {
+    if (typeof value !== "object" || value === null)
+        return undefined;
+    const field = value[key];
+    return typeof field === "string" || typeof field === "number"
+        ? field
+        : undefined;
+}

package/dist/file-content.js

@@ -1,5 +1,3 @@
-import { readFile } from "node:fs/promises";
-import { basename, extname, resolve } from "node:path";
 const MIME_TYPES = {
     ".csv": "text/csv",
     ".doc": "application/msword",
@@ -21,8 +19,8 @@ const MIME_TYPES = {
     ".xls": "application/vnd.ms-excel",
     ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
 };
-export function normalizeLocalFile(filePath, mimeType, projectRoot = process.cwd()) {
-    const absolutePath = resolve(projectRoot, filePath);
+export function normalizeLocalFile(filePath, mimeType, projectRoot = ".") {
+    const absolutePath = resolvePortablePath(projectRoot, filePath);
     return {
         type: "file",
         filePath: absolutePath,
@@ -47,22 +45,60 @@ export function normalizeUrlContent(url, mimeType) {
     };
 }
 export async function readLocalFileContent(content) {
+    const fsModule = "node:fs/promises";
+    const { readFile } = await import(fsModule);
     const bytes = await readFile(content.filePath);
     const base64 = bytes.toString("base64");
     return {
         bytes,
         base64,
         dataUri: `data:${content.mimeType};base64,${base64}`,
-        fileName: basename(content.filePath),
+        fileName: portableBasename(content.filePath),
     };
 }
 function normalizeMimeType(mimeType, source) {
     if (mimeType?.trim()) {
         return mimeType.trim().toLowerCase();
     }
-    const inferred = MIME_TYPES[extname(source).toLowerCase()];
+    const inferred = MIME_TYPES[portableExtension(source).toLowerCase()];
     if (!inferred) {
         throw new Error(`Could not infer a MIME type for "${source}". Provide mimeType explicitly.`);
     }
     return inferred;
 }
+function resolvePortablePath(root, filePath) {
+    if (/^(?:\/|[a-zA-Z]:[\\/])/.test(filePath)) {
+        return normalizePath(filePath);
+    }
+    return normalizePath(`${root.replace(/[\\/]+$/, "")}/${filePath}`);
+}
+function normalizePath(path) {
+    const separator = path.includes("\\") ? "\\" : "/";
+    const prefix = path.match(/^(?:[a-zA-Z]:)?[\\/]/)?.[0] ?? "";
+    const source = prefix ? path.slice(prefix.length) : path;
+    const parts = [];
+    for (const part of source.split(/[\\/]+/)) {
+        if (!part || part === ".") {
+            continue;
+        }
+        if (part === "..") {
+            if (parts.length > 0 && parts.at(-1) !== "..") {
+                parts.pop();
+            }
+            else if (!prefix) {
+                parts.push(part);
+            }
+            continue;
+        }
+        parts.push(part);
+    }
+    return `${prefix}${parts.join(separator)}` || ".";
+}
+function portableBasename(path) {
+    return path.split(/[\\/]/).at(-1) ?? path;
+}
+function portableExtension(path) {
+    const name = portableBasename(path);
+    const index = name.lastIndexOf(".");
+    return index > 0 ? name.slice(index) : "";
+}

package/dist/index.d.ts

@@ -1,8 +1,4 @@
 export { orcha } from "./orcha.js";
-export { OrchaError } from "./errors.js";
-export type { Orcha, OrchaClient } from "./orcha.js";
+export * from "./runtime-entry.js";
 export { NodeJsonlSessionStore } from "./storage/node-jsonl.js";
 export { NodeSqliteSessionStore } from "./storage/node-sqlite.js";
-export { exportSessionJsonl, migrateSessionStore, } from "./storage/migrate.js";
-export type { SessionStoreMigrationResult, } from "./storage/migrate.js";
-export type { ActionConfiguration, AgentTestActionConfiguration, AgentTestActionExpectation, AgentTestActionResponse, AgentTestAssertionResult, AgentTestCaseConfiguration, AgentTestCaseReport, AgentTestCaseSummary, AgentTestExpectation, AgentTestReport, AgentTestTextExpectation, AgentTestValueExpectation, AgentTestWarning, ApiKeyProviderConfiguration, AwsCredentials, AgentContinueInput, AgentConfiguration, AgentContentInput, AgentInput, AgentRegistration, AgentRuntime, ClientCapability, ClientToolCall, CompletedRunResult, CompiledActionManifest, CompiledAgentManifest, CompiledBundle, CompiledEvaluationManifest, CompiledSkillManifest, EvaluationConfiguration, EvaluationMetricConfiguration, EvaluationMetricResult, EvaluationResult, Execution, ExecutionSnapshot, FailedRunResult, FileContent, FilePathContentInput, LocalFileContent, LocalActionRuntimeConfiguration, MessageContent, MessageContentInput, MetadataValue, OrchaErrorCode, OrchaInitConfiguration, PausedRunResult, PaginationOptions, ProjectConfiguration, ProviderConfiguration, ProviderInitConfigurations, ProviderName, BedrockProviderConfiguration, RunError, RunStatus, RunTestsOptions, ResumeInput, RunResult, SessionEvent, SessionEventListOptions, SessionEvents, SessionEventType, SessionHistory, SessionHistoryItem, SessionList, SessionListOptions, SessionMetadata, SessionSnapshot, SessionStatus, SessionStore, SkillConfiguration, SessionUpdate, StreamingRunSnapshot, SubagentConfiguration, TextContent, ToolResult, ToolResumeInput, UrlContentInput, Usage, VertexAIProviderConfiguration, GoogleServiceAccountCredentials, WaitingRunResult, WaitingForSubagentSnapshot, } from "./types.js";

package/dist/index.js

@@ -1,5 +1,4 @@
 export { orcha } from "./orcha.js";
-export { OrchaError } from "./errors.js";
+export * from "./runtime-entry.js";
 export { NodeJsonlSessionStore } from "./storage/node-jsonl.js";
 export { NodeSqliteSessionStore } from "./storage/node-sqlite.js";
-export { exportSessionJsonl, migrateSessionStore, } from "./storage/migrate.js";

package/dist/integrations/esbuild.js

@@ -6,12 +6,15 @@ import { buildProject } from "../compiler/build-project.js";
  */
 export function orchaPlugin(options = {}) {
     const projectRoot = resolve(options.projectRoot ?? process.cwd());
-    const generatedBundle = resolve(projectRoot, ".orcha/dist/bundle.js");
     return {
         name: "orchajs",
         setup(builder) {
+            const target = builder.initialOptions.platform === "browser"
+                ? "browser"
+                : "node";
+            const generatedBundle = resolve(projectRoot, `.orcha/dist/${target === "node" ? "bundle.js" : "bundle.browser.js"}`);
             builder.onStart(async () => {
-                await buildProject({ projectRoot });
+                await buildProject({ projectRoot, target });
             });
             builder.onResolve({ filter: /^orchajs$/ }, () => ({
                 path: generatedBundle,

package/dist/integrations/expo.d.ts

@@ -0,0 +1 @@
+export { withOrchaMetro as withOrchaExpo, type OrchaMetroOptions as OrchaExpoOptions, } from "./metro.js";

package/dist/integrations/expo.js

@@ -0,0 +1 @@
+export { withOrchaMetro as withOrchaExpo, } from "./metro.js";

package/dist/integrations/metro.d.ts

@@ -0,0 +1,15 @@
+export interface OrchaMetroOptions {
+    projectRoot?: string;
+}
+interface MetroResolverContext {
+    resolveRequest(context: MetroResolverContext, moduleName: string, platform: string | null): unknown;
+}
+interface MetroConfiguration {
+    resolver?: {
+        resolveRequest?: MetroResolverContext["resolveRequest"];
+        [key: string]: unknown;
+    };
+    [key: string]: unknown;
+}
+export declare function withOrchaMetro<T extends MetroConfiguration>(configuration: T, options?: OrchaMetroOptions): Promise<T>;
+export {};

package/dist/integrations/metro.js

@@ -0,0 +1,25 @@
+import { resolve } from "node:path";
+import { generatedBundlePath, queueRuntimeBuild, watchRuntimeTargets, } from "./runtime-build.js";
+export async function withOrchaMetro(configuration, options = {}) {
+    const projectRoot = resolve(options.projectRoot ?? process.cwd());
+    await queueRuntimeBuild(projectRoot, "react-native");
+    if (process.env.NODE_ENV !== "production") {
+        watchRuntimeTargets(projectRoot, ["react-native"]);
+    }
+    const existingResolver = configuration.resolver?.resolveRequest;
+    return {
+        ...configuration,
+        resolver: {
+            ...configuration.resolver,
+            resolveRequest(context, moduleName, platform) {
+                const requestedModule = moduleName === "orchajs"
+                    ? generatedBundlePath(projectRoot, "react-native")
+                    : moduleName;
+                if (existingResolver) {
+                    return existingResolver(context, requestedModule, platform);
+                }
+                return context.resolveRequest(context, requestedModule, platform);
+            },
+        },
+    };
+}