@reasonlayer/sdk 0.0.1-rc.3

package/node_modules/@reasonlayer/runner/dist/flue-transcript.d.ts

@@ -0,0 +1,17 @@
+import type { AgentEvent } from "@reasonlayer/protocol";
+export type FlueEvent = Record<string, any>;
+export declare class FlueTranscriptMapper {
+    private readonly turnSeqByTurnId;
+    private nextTurnSeq;
+    private readonly pendingTools;
+    private readonly pendingTasks;
+    private readonly taskUsage;
+    map(event: FlueEvent): AgentEvent[];
+    private turnSeqFor;
+    private turn;
+    private tool;
+    private task;
+    private log;
+    terminalError(seq: number, error: unknown): AgentEvent;
+    private foldTaskUsage;
+}

package/node_modules/@reasonlayer/runner/dist/flue-transcript.js

@@ -0,0 +1,182 @@
+export class FlueTranscriptMapper {
+    turnSeqByTurnId = new Map();
+    nextTurnSeq = 0;
+    pendingTools = new Map();
+    pendingTasks = new Map();
+    taskUsage = new Map();
+    map(event) {
+        const turnSeq = event.turnId === undefined ? undefined : this.turnSeqFor(String(event.turnId));
+        const isTaskBoundary = event.type === "task_start" || event.type === "task";
+        if (event.taskId !== undefined && !isTaskBoundary) {
+            if (event.type === "turn")
+                this.foldTaskUsage(String(event.taskId), event);
+            return [];
+        }
+        switch (event.type) {
+            case "turn":
+                return [this.turn(event, turnSeq)];
+            case "tool_start":
+                this.pendingTools.set(String(event.toolCallId), {
+                    toolName: String(event.toolName),
+                    ...(event.args !== undefined ? { args: event.args } : {}),
+                    ...(turnSeq !== undefined ? { turnSeq } : {}),
+                });
+                return [];
+            case "tool":
+                return [this.tool(event, turnSeq)];
+            case "task_start":
+                this.pendingTasks.set(String(event.taskId), {
+                    ...(typeof event.agent === "string" ? { agent: event.agent } : {}),
+                    ...(typeof event.prompt === "string" ? { prompt: event.prompt } : {}),
+                    ...(turnSeq !== undefined ? { turnSeq } : {}),
+                });
+                return [];
+            case "task":
+                return [this.task(event, turnSeq)];
+            case "log":
+                return [this.log(event, turnSeq)];
+            default:
+                return [];
+        }
+    }
+    turnSeqFor(turnId) {
+        const existing = this.turnSeqByTurnId.get(turnId);
+        if (existing !== undefined)
+            return existing;
+        const assigned = this.nextTurnSeq++;
+        this.turnSeqByTurnId.set(turnId, assigned);
+        return assigned;
+    }
+    turn(event, turnSeq) {
+        const usage = usageFromTurn(event);
+        const text = textFromTurn(event);
+        const finishReason = typeof event.response?.finishReason === "string" ? event.response.finishReason : undefined;
+        const purpose = event.purpose === "agent" || event.purpose === "compaction" ? event.purpose : undefined;
+        return {
+            type: "agent.turn",
+            seq: event.eventIndex,
+            ...(turnSeq !== undefined ? { turnSeq } : {}),
+            level: event.isError ? "error" : "info",
+            ts: millis(event.timestamp),
+            data: {
+                ...(usage.model ? { model: usage.model } : {}),
+                ...(text !== undefined ? { text } : {}),
+                ...(finishReason !== undefined ? { finishReason } : {}),
+                ...(purpose !== undefined ? { purpose } : {}),
+                usage,
+            },
+        };
+    }
+    tool(event, turnSeq) {
+        const pending = this.pendingTools.get(String(event.toolCallId));
+        this.pendingTools.delete(String(event.toolCallId));
+        const assignedTurnSeq = pending?.turnSeq ?? turnSeq;
+        return {
+            type: "agent.tool",
+            seq: event.eventIndex,
+            ...(assignedTurnSeq !== undefined ? { turnSeq: assignedTurnSeq } : {}),
+            level: event.isError ? "error" : "info",
+            ts: millis(event.timestamp),
+            data: {
+                toolName: String(event.toolName),
+                ...(pending?.args !== undefined ? { args: pending.args } : {}),
+                ...(event.result !== undefined ? { result: event.result } : {}),
+                ok: !event.isError,
+                durationMs: Number(event.durationMs ?? 0),
+            },
+        };
+    }
+    task(event, turnSeq) {
+        const pending = this.pendingTasks.get(String(event.taskId));
+        this.pendingTasks.delete(String(event.taskId));
+        const usage = this.taskUsage.get(String(event.taskId)) ?? {
+            inputTokens: 0,
+            outputTokens: 0,
+            costUsd: 0,
+        };
+        this.taskUsage.delete(String(event.taskId));
+        const assignedTurnSeq = pending?.turnSeq ?? turnSeq;
+        return {
+            type: "agent.task",
+            seq: event.eventIndex,
+            ...(assignedTurnSeq !== undefined ? { turnSeq: assignedTurnSeq } : {}),
+            level: event.isError ? "error" : "info",
+            ts: millis(event.timestamp),
+            data: {
+                ...(event.agent ?? pending?.agent ? { agent: event.agent ?? pending?.agent } : {}),
+                ...(pending?.prompt !== undefined ? { prompt: pending.prompt } : {}),
+                ...(event.result !== undefined ? { result: event.result } : {}),
+                ok: !event.isError,
+                durationMs: Number(event.durationMs ?? 0),
+                usage,
+            },
+        };
+    }
+    log(event, turnSeq) {
+        return {
+            type: "agent.log",
+            seq: event.eventIndex,
+            ...(turnSeq !== undefined ? { turnSeq } : {}),
+            level: event.level === "debug" ||
+                event.level === "warn" ||
+                event.level === "error"
+                ? event.level
+                : "info",
+            ts: millis(event.timestamp),
+            data: {
+                message: String(event.message ?? ""),
+                ...(event.attributes ? { fields: event.attributes } : {}),
+            },
+        };
+    }
+    terminalError(seq, error) {
+        const message = error instanceof Error
+            ? error.message
+            : typeof error === "object" && error && "message" in error
+                ? String(error.message)
+                : String(error ?? "unknown error");
+        const kind = error instanceof Error ? error.name : undefined;
+        return {
+            type: "agent.error",
+            seq,
+            level: "error",
+            ts: Date.now(),
+            data: { message, ...(kind ? { kind } : {}) },
+        };
+    }
+    foldTaskUsage(taskId, event) {
+        const usage = usageFromTurn(event);
+        const current = this.taskUsage.get(taskId) ?? { inputTokens: 0, outputTokens: 0, costUsd: 0 };
+        this.taskUsage.set(taskId, {
+            ...(usage.model ? { model: usage.model } : current.model ? { model: current.model } : {}),
+            inputTokens: current.inputTokens + usage.inputTokens,
+            outputTokens: current.outputTokens + usage.outputTokens,
+            costUsd: current.costUsd + usage.costUsd,
+        });
+    }
+}
+function usageFromTurn(event) {
+    const usage = event.response?.usage;
+    return {
+        ...(event.response?.responseModel ? { model: String(event.response.responseModel) } : {}),
+        inputTokens: Number(usage?.input ?? 0),
+        outputTokens: Number(usage?.output ?? 0),
+        costUsd: Number(usage?.cost?.total ?? 0),
+    };
+}
+function textFromTurn(event) {
+    const content = event.response?.output?.content;
+    if (!Array.isArray(content))
+        return undefined;
+    const text = content
+        .filter((block) => block?.type === "text" && typeof block.text === "string")
+        .map((block) => block.text)
+        .join("");
+    return text || undefined;
+}
+function millis(value) {
+    if (typeof value !== "string")
+        return Date.now();
+    const parsed = Date.parse(value);
+    return Number.isNaN(parsed) ? Date.now() : parsed;
+}

package/node_modules/@reasonlayer/runner/dist/index.d.ts

@@ -0,0 +1,184 @@
+import { type AgentEvent, type HostIR, type RunReadModel, type TaskResult, type TaskSpec } from "@reasonlayer/protocol";
+import type { SessionEnv, ToolDefinition } from "@flue/runtime";
+export interface RunnerConfig {
+    convexUrl: string;
+    token: string;
+}
+export interface RunnerBackendConfig {
+    convexUrl: string;
+}
+export interface RunDeviceClaimLoopOptions extends RunnerBackendConfig {
+    deviceToken?: string;
+    deviceTokenProvider?: () => Promise<string>;
+    runnerId?: string;
+    pollIntervalMs?: number;
+    leaseMs?: number;
+    once?: boolean;
+    cacheDir?: string;
+}
+export interface RunDispatchedTaskOptions extends RunnerBackendConfig {
+    taskId: string;
+    dispatchToken: string;
+    sandboxId?: string;
+    runnerId?: string;
+    leaseMs?: number;
+    cacheDir?: string;
+}
+export interface RunTestRunOptions extends RunnerConfig {
+    runId: string;
+    executorToken: string;
+    runnerId?: string;
+    pollIntervalMs?: number;
+    leaseMs?: number;
+    cacheDir?: string;
+    concurrency?: number;
+    signal?: AbortSignal;
+    client?: RunnerClient;
+    executor?: TaskExecutor;
+}
+export interface ClaimedTask {
+    task: TaskSpec;
+    taskToken: string;
+}
+export interface RunnerClient {
+    query<T>(name: string, args: Record<string, unknown>): Promise<T>;
+    mutation<T>(name: string, args: Record<string, unknown>): Promise<T>;
+    action<T>(name: string, args: Record<string, unknown>): Promise<T>;
+}
+export interface TaskSource {
+    readonly label: string;
+    readonly stopWhenIdle?: boolean;
+    readonly taskOptions?: Pick<RunClaimOptions, "verifyDeviceEnvironments">;
+    claim(client: RunnerClient, runnerId: string, leaseMs: number | undefined): Promise<ClaimedTask | null>;
+}
+export interface TaskExecutor {
+    run(claim: ClaimedTask, options: {
+        cacheDir?: string;
+        leaseMs?: number;
+        materializeEnvironments?: boolean;
+        verifyDeviceEnvironments?: boolean;
+        signal?: AbortSignal;
+    }): Promise<TaskResult>;
+}
+export interface RunClaimOptions {
+    cacheDir?: string;
+    leaseMs?: number;
+    materializeEnvironments?: boolean;
+    verifyDeviceEnvironments?: boolean;
+    signal?: AbortSignal;
+    /** Test seam; production uses RunnerConvexClient. */
+    client?: RunnerClient;
+    /** Test seam; production derives this from the lease duration. Clamped to the shared lease floor. */
+    heartbeatIntervalMs?: number;
+    /** Test seam; production runs each task in a killable child process group. */
+    processAdapter?: TaskProcessAdapter;
+}
+export interface RunTaskLoopOptions extends RunnerBackendConfig {
+    source: TaskSource;
+    executor?: TaskExecutor;
+    runnerId?: string;
+    pollIntervalMs?: number;
+    leaseMs?: number;
+    once?: boolean;
+    cacheDir?: string;
+    materializeEnvironments?: boolean;
+    verifyDeviceEnvironments?: boolean;
+    signal?: AbortSignal;
+    client?: RunnerClient;
+}
+export interface TaskProcessReporter {
+    push(event: AgentEvent): Promise<void>;
+}
+export interface TaskProcessRunOptions {
+    convexUrl: string;
+    cacheDir?: string;
+    materializeEnvironments?: boolean;
+    verifyDeviceEnvironments?: boolean;
+    signal: AbortSignal;
+    reporter: TaskProcessReporter;
+}
+export interface TaskProcessAdapter {
+    run(claim: ClaimedTask, options: TaskProcessRunOptions): Promise<unknown>;
+}
+export declare class RunnerConvexClient implements RunnerClient {
+    readonly config: RunnerBackendConfig;
+    private readonly client;
+    constructor(config: RunnerBackendConfig);
+    query<T>(name: string, args: Record<string, unknown>): Promise<T>;
+    mutation<T>(name: string, args: Record<string, unknown>): Promise<T>;
+    action<T>(name: string, args: Record<string, unknown>): Promise<T>;
+}
+export declare function defaultDeviceRunnerId(): string;
+export declare function defaultOrgRunnerId(): string;
+export declare const TASK_ENV_CONCURRENCY = 1;
+export declare const DEFAULT_DEVICE_POLL_INTERVAL_MS = 30000;
+export declare class TranscriptReporter {
+    private readonly client;
+    private readonly claim;
+    private readonly secrets;
+    private readonly buffer;
+    private flushing;
+    private readonly flushTimer;
+    constructor(client: RunnerClient, claim: ClaimedTask, secrets: readonly string[]);
+    push(event: AgentEvent): Promise<void>;
+    flush(): Promise<void>;
+    close(): Promise<void>;
+}
+export interface AgentContext {
+    env: Record<string, string>;
+    signal: AbortSignal;
+    runId: string;
+    stepId: string;
+    outputSchemaJsonText: string;
+    host: HostIR;
+    emit: (event: AgentEvent) => Promise<void>;
+}
+export interface FlueCoordinatorAdapter {
+    createAdmission(agentName: string, instanceId: string): (request: {
+        message: string;
+    }, onEvent: () => void, wait: boolean) => Promise<void>;
+    waitForIdle(): Promise<void>;
+    abortInstance(agentName: string, instanceId: string): Promise<void>;
+    shutdown(timeoutMs: number): Promise<void>;
+}
+export interface FlueRuntimeAdapter {
+    observe(handler: (event: any) => void): () => void;
+    createInstrumentationOwner(): unknown;
+    runWithInstrumentationOwner<T>(owner: unknown, fn: () => Promise<T>): Promise<T>;
+}
+export declare function catalogToolDefinitions(actionIds: readonly string[]): ToolDefinition[];
+/**
+ * Inject runner-owned tools into the agent's resolved runtime config — the
+ * definition alone can't know them (the runner owns catalog access and MCP
+ * server startup/port allocation).
+ */
+export declare function withMcpTools(agent: unknown, tools: ToolDefinition[]): unknown;
+export declare function createDefaultFlueSessionEnv(_host: HostIR, cwd?: string): SessionEnv;
+export declare function runFlueStepWithCoordinator(input: unknown, context: AgentContext, adapters: {
+    runtime: FlueRuntimeAdapter;
+    coordinator: FlueCoordinatorAdapter;
+}): Promise<unknown>;
+export declare function extractOutput(result: unknown, outputSchemaJsonText: string): unknown;
+export declare function executeClaimTask(claim: ClaimedTask, options: TaskProcessRunOptions): Promise<unknown>;
+export declare function createInProcessTaskProcessAdapter(): TaskProcessAdapter;
+export declare function createSubprocessTaskProcessAdapter(options?: {
+    childEntryPath?: string;
+}): TaskProcessAdapter;
+export declare function runClaim(config: RunnerBackendConfig, claim: ClaimedTask, options?: RunClaimOptions): Promise<TaskResult>;
+export declare function runScopedSource(options: {
+    runId: string;
+    executorToken: string;
+}): TaskSource;
+export declare function deviceJwtSource(options: {
+    deviceToken?: string;
+    deviceTokenProvider?: () => Promise<string>;
+}): TaskSource;
+export declare function dispatchTokenSource(options: {
+    taskId: string;
+    dispatchToken: string;
+    sandboxId?: string;
+}): TaskSource;
+export declare function runTaskLoop(options: RunTaskLoopOptions): Promise<TaskResult | undefined>;
+export declare function runTestRun(options: RunTestRunOptions): Promise<RunReadModel>;
+export declare function runDispatchedTask(options: RunDispatchedTaskOptions): Promise<TaskResult>;
+export declare function runDeviceClaimLoop(options: RunDeviceClaimLoopOptions): Promise<void>;