orchajs 0.20.3 → 0.22.0

package/dist/runtime/compiler-hook.js

@@ -0,0 +1,8 @@
+let registryCompiler;
+/** @internal Installed by Node development tooling, never by runtime bundles. */
+export function setRegistryCompiler(compiler) {
+    registryCompiler = compiler;
+}
+export function getRegistryCompiler() {
+    return registryCompiler;
+}

package/dist/runtime/create-orcha.d.ts

@@ -1,11 +1,16 @@
 import type { ProviderResponseGenerator } from "../providers/types.js";
+import type { RuntimePlatform } from "./platform.js";
 import type { AgentRuntime, CompiledBundle, OrchaInitConfiguration } from "../types.js";
 export interface Orcha {
     init(configuration: OrchaInitConfiguration): OrchaClient;
     isInitialized(): boolean;
+    /** Flushes queued Amarsia telemetry without blocking normal agent runs. */
+    flushTelemetry(options?: {
+        timeoutMs?: number;
+    }): Promise<void>;
     /** @internal Used by the development compiler. */
     getCompiledBundle(): CompiledBundle;
 }
 export type OrchaClient = Orcha & Record<string, AgentRuntime>;
 export type BundleResolver = (configuration: OrchaInitConfiguration) => CompiledBundle;
-export declare function createOrcha(resolveBundle: BundleResolver, generateProviderResponse: ProviderResponseGenerator): OrchaClient;
+export declare function createOrcha(resolveBundle: BundleResolver, generateProviderResponse: ProviderResponseGenerator, platform: RuntimePlatform): OrchaClient;

package/dist/runtime/create-orcha.js

@@ -1,32 +1,33 @@
-import { resolve } from "node:path";
 import { RuntimeAgent } from "./agent.js";
-import { createSessionStore } from "../storage/create-store.js";
-import { syncAmarsiaProject } from "../amarsia/sync.js";
+import { AmarsiaTelemetryClient, withAmarsiaTelemetry, } from "../amarsia/analytics.js";
 import { setOrchaRuntimeContext } from "./context.js";
 class OrchaRuntimeCore {
     #agents = new Map();
     #bundle;
     #client;
+    #telemetry;
     #activeSessions = new Set();
     #sessionControls = new Map();
     #resolveBundle;
     #generateProviderResponse;
-    constructor(resolveBundle, generateProviderResponse) {
+    #platform;
+    constructor(resolveBundle, generateProviderResponse, platform) {
         this.#resolveBundle = resolveBundle;
         this.#generateProviderResponse = generateProviderResponse;
+        this.#platform = platform;
     }
     attachClient(client) {
         this.#client = client;
     }
     init(configuration) {
-        const projectRoot = resolve(configuration.root ??
-            process.env.ORCHA_PROJECT_ROOT ??
-            process.cwd());
-        const bundle = this.#resolveBundle(configuration);
-        if (configuration.amarsia?.key) {
-            syncAmarsiaProject({
-                key: configuration.amarsia.key,
-                endpoint: configuration.amarsia.endpoint,
+        if (this.#telemetry) {
+            void this.#telemetry.close();
+        }
+        const projectRoot = this.#platform.projectRoot(configuration);
+        const bundle = configuration.bundle ?? this.#resolveBundle(configuration);
+        if (configuration.amarsia?.key && this.#platform.syncProject) {
+            this.#platform.syncProject({
+                configuration,
                 bundle,
                 projectRoot,
             });
@@ -46,13 +47,21 @@ class OrchaRuntimeCore {
             runtimeConfiguration.actions?.runtime !== bundle.actionRuntime) {
             throw new Error(`Production bundle expects local action runtime "${bundle.actionRuntime}".`);
         }
-        const storageDirectory = configuration.storage?.directory ?? ".orcha/sessions";
-        const createStore = (manifest) => createSessionStore({
-            strategy: configuration.storage?.strategy,
-            directory: storageDirectory,
+        const createStore = (manifest) => this.#platform.createSessionStore({
+            configuration,
             projectRoot,
-            agentName: manifest.key ?? manifest.name,
+            manifest,
         });
+        const telemetry = configuration.amarsia?.key
+            ? new AmarsiaTelemetryClient(configuration.amarsia)
+            : undefined;
+        this.#telemetry = telemetry;
+        const createRuntimeStore = (manifest) => {
+            const store = createStore(manifest);
+            return telemetry
+                ? withAmarsiaTelemetry({ store, manifest, client: telemetry })
+                : store;
+        };
         const agents = new Map();
         for (const [name, manifest] of Object.entries(bundle.agents)) {
             const subagents = Object.fromEntries(Object.entries(manifest.subagents ?? {}).map(([subagentName, subagentManifest]) => [
@@ -60,23 +69,25 @@ class OrchaRuntimeCore {
                 new RuntimeAgent({
                     manifest: subagentManifest,
                     configuration: runtimeConfiguration,
-                    store: createStore(subagentManifest),
+                    store: createRuntimeStore(subagentManifest),
                     activeSessions: this.#activeSessions,
                     sessionControls: this.#sessionControls,
                     generateProviderResponse: this.#generateProviderResponse,
                     delegatedOnly: true,
                     projectRoot,
+                    randomUUID: this.#platform.randomUUID,
                 }),
             ]));
             agents.set(name, new RuntimeAgent({
                 manifest,
                 configuration: runtimeConfiguration,
-                store: createStore(manifest),
+                store: createRuntimeStore(manifest),
                 activeSessions: this.#activeSessions,
                 sessionControls: this.#sessionControls,
                 generateProviderResponse: this.#generateProviderResponse,
                 subagents,
                 projectRoot,
+                randomUUID: this.#platform.randomUUID,
             }));
         }
         this.#bundle = bundle;
@@ -93,6 +104,9 @@ class OrchaRuntimeCore {
     isInitialized() {
         return this.#bundle !== undefined;
     }
+    async flushTelemetry(options) {
+        await this.#telemetry?.drain(options);
+    }
     getCompiledBundle() {
         if (!this.#bundle) {
             throw new Error("Orcha has not been initialized.");
@@ -103,8 +117,8 @@ class OrchaRuntimeCore {
         return this.#agents.get(name);
     }
 }
-export function createOrcha(resolveBundle, generateProviderResponse) {
-    const core = new OrchaRuntimeCore(resolveBundle, generateProviderResponse);
+export function createOrcha(resolveBundle, generateProviderResponse, platform) {
+    const core = new OrchaRuntimeCore(resolveBundle, generateProviderResponse, platform);
     const client = new Proxy(core, {
         get(target, property) {
             if (typeof property === "string") {

package/dist/runtime/platform-browser.d.ts

@@ -0,0 +1,2 @@
+import type { RuntimePlatform } from "./platform.js";
+export declare const browserRuntimePlatform: RuntimePlatform;

package/dist/runtime/platform-browser.js

@@ -0,0 +1,15 @@
+import { BrowserIndexedDbSessionStore } from "../storage/browser-indexeddb.js";
+import { portableRandomUUID } from "./random-id.js";
+export const browserRuntimePlatform = {
+    randomUUID: portableRandomUUID,
+    projectRoot(configuration) {
+        return configuration.root ?? "/";
+    },
+    createSessionStore({ configuration, manifest }) {
+        const strategy = configuration.storage?.strategy ?? "indexeddb";
+        if (strategy !== "indexeddb") {
+            throw new Error(`Browser runtimes require storage strategy "indexeddb", received "${strategy}".`);
+        }
+        return new BrowserIndexedDbSessionStore(manifest.key ?? manifest.name, configuration.storage?.directory ?? "orchajs");
+    },
+};

package/dist/runtime/platform-node.d.ts

@@ -0,0 +1,2 @@
+import type { RuntimePlatform } from "./platform.js";
+export declare const nodeRuntimePlatform: RuntimePlatform;

package/dist/runtime/platform-node.js

@@ -0,0 +1,31 @@
+import { randomUUID } from "node:crypto";
+import { resolve } from "node:path";
+import { syncAmarsiaProject } from "../amarsia/sync.js";
+import { createSessionStore } from "../storage/create-store.js";
+export const nodeRuntimePlatform = {
+    randomUUID,
+    projectRoot(configuration) {
+        return resolve(configuration.root ??
+            process.env.ORCHA_PROJECT_ROOT ??
+            process.cwd());
+    },
+    createSessionStore({ configuration, projectRoot, manifest }) {
+        return createSessionStore({
+            strategy: configuration.storage?.strategy,
+            directory: configuration.storage?.directory,
+            projectRoot,
+            agentName: manifest.key ?? manifest.name,
+        });
+    },
+    syncProject({ configuration, bundle, projectRoot }) {
+        if (!configuration.amarsia?.key) {
+            return;
+        }
+        syncAmarsiaProject({
+            key: configuration.amarsia.key,
+            endpoint: configuration.amarsia.endpoint,
+            bundle,
+            projectRoot,
+        });
+    },
+};

package/dist/runtime/platform-react-native.d.ts

@@ -0,0 +1,2 @@
+import type { RuntimePlatform } from "./platform.js";
+export declare const reactNativeRuntimePlatform: RuntimePlatform;

package/dist/runtime/platform-react-native.js

@@ -0,0 +1,15 @@
+import { ReactNativeJsonlSessionStore } from "../storage/react-native-jsonl.js";
+import { portableRandomUUID } from "./random-id.js";
+export const reactNativeRuntimePlatform = {
+    randomUUID: portableRandomUUID,
+    projectRoot(configuration) {
+        return configuration.root ?? "/";
+    },
+    createSessionStore({ configuration, manifest }) {
+        const strategy = configuration.storage?.strategy ?? "react-native";
+        if (strategy !== "react-native") {
+            throw new Error(`React Native requires storage strategy "react-native", received "${strategy}".`);
+        }
+        return new ReactNativeJsonlSessionStore(manifest.key ?? manifest.name);
+    },
+};

package/dist/runtime/platform.d.ts

@@ -0,0 +1,15 @@
+import type { CompiledAgentManifest, CompiledBundle, OrchaInitConfiguration, SessionStore } from "../types.js";
+export interface RuntimePlatform {
+    randomUUID(): string;
+    projectRoot(configuration: OrchaInitConfiguration): string;
+    createSessionStore(options: {
+        configuration: OrchaInitConfiguration;
+        projectRoot: string;
+        manifest: CompiledAgentManifest;
+    }): SessionStore;
+    syncProject?(options: {
+        configuration: OrchaInitConfiguration;
+        bundle: CompiledBundle;
+        projectRoot: string;
+    }): void;
+}

package/dist/runtime/platform.js

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

package/dist/runtime/random-id.d.ts

@@ -0,0 +1 @@
+export declare function portableRandomUUID(): string;

package/dist/runtime/random-id.js

@@ -0,0 +1,26 @@
+let fallbackSequence = 0;
+export function portableRandomUUID() {
+    const crypto = globalThis.crypto;
+    if (typeof crypto?.randomUUID === "function") {
+        return crypto.randomUUID();
+    }
+    if (typeof crypto?.getRandomValues === "function") {
+        return formatUuid(crypto.getRandomValues(new Uint8Array(16)));
+    }
+    fallbackSequence = (fallbackSequence + 1) >>> 0;
+    const bytes = new Uint8Array(16);
+    let state = Date.now() ^
+        fallbackSequence ^
+        Math.floor(Math.random() * 0x1_0000_0000);
+    for (let index = 0; index < bytes.length; index += 1) {
+        state = (Math.imul(state, 1_664_525) + 1_013_904_223) >>> 0;
+        bytes[index] = state >>> 24;
+    }
+    return formatUuid(bytes);
+}
+function formatUuid(bytes) {
+    bytes[6] = (bytes[6] & 0x0f) | 0x40;
+    bytes[8] = (bytes[8] & 0x3f) | 0x80;
+    const value = Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+    return `${value.slice(0, 8)}-${value.slice(8, 12)}-${value.slice(12, 16)}-${value.slice(16, 20)}-${value.slice(20)}`;
+}

package/dist/runtime-entry.d.ts

@@ -0,0 +1,5 @@
+export { OrchaError } from "./errors.js";
+export type { Orcha, OrchaClient, } from "./runtime/create-orcha.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/runtime-entry.js

@@ -0,0 +1,2 @@
+export { OrchaError } from "./errors.js";
+export { exportSessionJsonl, migrateSessionStore, } from "./storage/migrate.js";

package/dist/storage/browser-indexeddb.d.ts

@@ -1,20 +1,11 @@
 import type { SessionEvent, SessionStore } from "../types.js";
-/**
- * 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.
- */
 export declare class BrowserIndexedDbSessionStore implements SessionStore {
-    read(_sessionId: string): Promise<SessionEvent[]>;
-    append(_sessionId: string, _events: SessionEvent[]): Promise<void>;
+    #private;
+    constructor(namespace: string, databaseName?: 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/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;
@@ -62,6 +64,57 @@ export interface OrchaInitConfiguration {
     storage?: ProjectConfiguration["storage"];
     root?: string;
 }
+/** Privacy-safe, versioned run fact sent to Amarsia when `amarsia.key` is set. */
+export interface AmarsiaTelemetryRunV1 {
+    event_id: string;
+    agent_external_id: string;
+    session_id: string;
+    run_number: number;
+    parent_agent_external_id?: string;
+    parent_session_id?: string;
+    status: string;
+    provider: string;
+    model: string;
+    region?: string;
+    output_type?: string;
+    stop_reason?: string;
+    started_at: string;
+    ended_at?: string;
+    duration_ms?: number;
+    model_duration_ms: number;
+    action_duration_ms: number;
+    input_tokens: number;
+    output_tokens: number;
+    reasoning_tokens?: number;
+    cache_read_tokens: number;
+    cache_write_tokens: number;
+    user_message_count: number;
+    assistant_message_count: number;
+    action_count: number;
+    action_success_count: number;
+    action_failure_count: number;
+    subagent_count: number;
+    actions: AmarsiaTelemetryActionV1[];
+    evaluation_count: number;
+    evaluation_pass_count: number;
+    error_code?: string;
+    error_message?: string;
+    error_retryable?: boolean;
+}
+export interface AmarsiaTelemetryActionV1 {
+    call_id: string;
+    name: string;
+    status: "completed" | "failed";
+    started_at: string;
+    ended_at: string;
+    duration_ms: number;
+    error_code?: string;
+    error_message?: string;
+}
+export interface AmarsiaTelemetryBatchV1 {
+    schema_version: 1;
+    runs: AmarsiaTelemetryRunV1[];
+}
 export interface SubagentConfiguration {
     maxPerRun?: number;
 }