orchajs 0.21.0 → 0.23.0

package/dist/runtime/agent.js

@@ -1,4 +1,4 @@
-import { OrchaError } from "../errors.js";
+import { describeProviderError, isRetryableProviderConnectionError, OrchaError, } from "../errors.js";
 import { normalizeLocalFile, normalizeUrlContent, } from "../file-content.js";
 import { messagesFromEvents, normalizePersistedToolResults, SessionEventWriter, } from "./session-events.js";
 import { validateStructuredValue } from "./structured-output.js";
@@ -620,7 +620,8 @@ export class RuntimeAgent {
             }
             providerTools.push(...this.#subagentToolDefinitions());
             try {
-                response = await this.#generateProviderResponse(this.#manifest.provider, provider, {
+                const signal = this.#sessionControls.get(sessionId)?.controller.signal;
+                response = await withProviderConnectionRetry(() => this.#generateProviderResponse(this.#manifest.provider, provider, {
                     model: this.#manifest.model,
                     region: this.#manifest.region,
                     maxTokens: this.#manifest.maxTokens,
@@ -634,8 +635,8 @@ export class RuntimeAgent {
                         streamedOutput = output;
                         publishOutput?.(output);
                     },
-                    signal: this.#sessionControls.get(sessionId)?.controller.signal,
-                });
+                    signal,
+                }), signal);
             }
             catch (error) {
                 if (this.#sessionControls.get(sessionId)?.pauseRequested) {
@@ -665,7 +666,16 @@ export class RuntimeAgent {
                 if (error instanceof OrchaError) {
                     throw error;
                 }
-                throw new OrchaError("provider_error", error instanceof Error ? error.message : String(error), { retryable: true, cause: error });
+                const providerError = describeProviderError(error);
+                throw new OrchaError("provider_error", providerError.message, {
+                    retryable: true,
+                    cause: error,
+                    details: {
+                        provider: this.#manifest.provider,
+                        model: this.#manifest.model,
+                        ...providerError.details,
+                    },
+                });
             }
             const modelDurationMs = Math.round(performance.now() - modelStartedAt);
             const usage = aggregateUsage(previousEvents, writer.run, response.usage);
@@ -2609,6 +2619,21 @@ function findLast(events, predicate) {
     }
     return undefined;
 }
+async function withProviderConnectionRetry(operation, signal) {
+    try {
+        return await operation();
+    }
+    catch (error) {
+        if (signal?.aborted ||
+            !isRetryableProviderConnectionError(error)) {
+            throw error;
+        }
+        await new Promise((resolve) => setTimeout(resolve, 250));
+        if (signal?.aborted)
+            throw error;
+        return operation();
+    }
+}
 function failure(sessionId, code, message, options = {}) {
     const retryable = options.retryable ??
         (code === "session_busy" ||

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

@@ -4,6 +4,10 @@ import type { AgentRuntime, CompiledBundle, OrchaInitConfiguration } from "../ty
 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;
 }

package/dist/runtime/create-orcha.js

@@ -1,9 +1,11 @@
 import { RuntimeAgent } from "./agent.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;
@@ -18,6 +20,9 @@ class OrchaRuntimeCore {
         this.#client = client;
     }
     init(configuration) {
+        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) {
@@ -47,6 +52,16 @@ class OrchaRuntimeCore {
             projectRoot,
             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]) => [
@@ -54,7 +69,7 @@ class OrchaRuntimeCore {
                 new RuntimeAgent({
                     manifest: subagentManifest,
                     configuration: runtimeConfiguration,
-                    store: createStore(subagentManifest),
+                    store: createRuntimeStore(subagentManifest),
                     activeSessions: this.#activeSessions,
                     sessionControls: this.#sessionControls,
                     generateProviderResponse: this.#generateProviderResponse,
@@ -66,7 +81,7 @@ class OrchaRuntimeCore {
             agents.set(name, new RuntimeAgent({
                 manifest,
                 configuration: runtimeConfiguration,
-                store: createStore(manifest),
+                store: createRuntimeStore(manifest),
                 activeSessions: this.#activeSessions,
                 sessionControls: this.#sessionControls,
                 generateProviderResponse: this.#generateProviderResponse,
@@ -89,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.");

package/dist/types.d.ts

@@ -64,6 +64,84 @@ 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;
+    evaluation_failure_count: number;
+    evaluation_error_count: number;
+    evaluation_metric_count: number;
+    evaluation_metric_pass_count: number;
+    evaluations: AmarsiaTelemetryEvaluationV1[];
+    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 AmarsiaTelemetryEvaluationMetricV1 {
+    name: string;
+    score: number;
+    threshold: number;
+    passed: boolean;
+    reasoning: string;
+    evidence: string[];
+}
+export interface AmarsiaTelemetryEvaluationV1 {
+    name: string;
+    status: "passed" | "failed" | "error";
+    provider?: string;
+    model?: string;
+    duration_ms: number;
+    input_tokens: number;
+    output_tokens: number;
+    reasoning_tokens: number;
+    cache_read_tokens: number;
+    cache_write_tokens: number;
+    metrics: AmarsiaTelemetryEvaluationMetricV1[];
+    error_message?: string;
+}
+export interface AmarsiaTelemetryBatchV1 {
+    schema_version: 1;
+    runs: AmarsiaTelemetryRunV1[];
+}
 export interface SubagentConfiguration {
     maxPerRun?: number;
 }