ultracode-for-codex 0.2.0

package/dist/runtime/async-queue.js

@@ -0,0 +1,55 @@
+export class AsyncQueue {
+    values = [];
+    resolvers = [];
+    error = null;
+    closed = false;
+    push(value) {
+        if (this.closed)
+            return;
+        const resolve = this.resolvers.shift();
+        if (resolve)
+            resolve({ done: false, value });
+        else
+            this.values.push(value);
+    }
+    fail(err) {
+        if (this.closed)
+            return;
+        this.error = err;
+        this.closed = true;
+        while (this.resolvers.length > 0) {
+            const resolve = this.resolvers.shift();
+            resolve?.({ done: true, value: undefined });
+        }
+    }
+    close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        while (this.resolvers.length > 0) {
+            const resolve = this.resolvers.shift();
+            resolve?.({ done: true, value: undefined });
+        }
+    }
+    async *[Symbol.asyncIterator]() {
+        while (true) {
+            if (this.values.length > 0) {
+                yield this.values.shift();
+                continue;
+            }
+            if (this.error)
+                throw this.error;
+            if (this.closed)
+                return;
+            const next = await new Promise((resolve) => {
+                this.resolvers.push(resolve);
+            });
+            if (next.done) {
+                if (this.error)
+                    throw this.error;
+                return;
+            }
+            yield next.value;
+        }
+    }
+}

package/dist/runtime/types.d.ts

@@ -0,0 +1,61 @@
+export type ReasoningEffort = 'none' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh';
+export type Verbosity = 'low' | 'medium' | 'high';
+export interface SubagentMessage {
+    readonly role: 'user';
+    readonly content: string;
+}
+export interface SubagentTool {
+    readonly name: string;
+    readonly description?: string;
+    readonly inputSchema?: unknown;
+}
+export type SubagentToolChoice = {
+    readonly type: 'auto';
+} | {
+    readonly type: 'required';
+};
+export interface SubagentRequest {
+    readonly model: string;
+    readonly messages: readonly SubagentMessage[];
+    readonly reasoningEffort?: ReasoningEffort;
+    readonly tools: readonly SubagentTool[];
+    readonly toolChoice: SubagentToolChoice;
+    readonly worktreePath?: string;
+    readonly raw?: unknown;
+}
+export interface SubagentUsage {
+    readonly inputTokens: number;
+    readonly outputTokens: number;
+    readonly totalTokens?: number;
+    readonly cachedInputTokens?: number;
+    readonly reasoningOutputTokens?: number;
+    readonly source?: 'provider' | 'estimated';
+    readonly raw?: unknown;
+}
+export interface SubagentToolCall {
+    readonly id: string;
+    readonly name: string;
+    readonly arguments: string;
+}
+export interface SubagentResult {
+    readonly id: string;
+    readonly model: string;
+    readonly text: string;
+    readonly toolCalls: readonly SubagentToolCall[];
+    readonly usage: SubagentUsage;
+    readonly latencyMs: number;
+}
+export interface SubagentBackend {
+    readonly name: string;
+    readonly model: string;
+    generate(request: SubagentRequest, signal?: AbortSignal): Promise<SubagentResult>;
+    close(): Promise<void>;
+}
+export declare class UltracodeRequestError extends Error {
+    readonly statusCode: number;
+    readonly type: string;
+    readonly param: string | null;
+    readonly code: string | null;
+    constructor(message: string, statusCode: number, type?: string, param?: string | null, code?: string | null);
+}
+export declare function estimateTokens(text: string): number;

package/dist/runtime/types.js

@@ -0,0 +1,18 @@
+export class UltracodeRequestError extends Error {
+    statusCode;
+    type;
+    param;
+    code;
+    constructor(message, statusCode, type = 'invalid_request_error', param = null, code = null) {
+        super(message);
+        this.statusCode = statusCode;
+        this.type = type;
+        this.param = param;
+        this.code = code;
+    }
+}
+export function estimateTokens(text) {
+    if (!text)
+        return 0;
+    return Math.max(1, Math.ceil(text.length / 4));
+}

package/dist/runtime/workflow-journal.d.ts

@@ -0,0 +1,135 @@
+export type JsonValue = null | boolean | number | string | readonly JsonValue[] | {
+    readonly [key: string]: JsonValue;
+};
+export interface WorkflowJournalUsage {
+    readonly inputTokens: number;
+    readonly outputTokens: number;
+    readonly totalTokens: number;
+}
+export interface WorkflowAgentSemanticOpts {
+    readonly schema?: JsonValue;
+    readonly model: string;
+    readonly effort?: string;
+    readonly isolation?: string;
+    readonly agentType?: string;
+}
+export type WorkflowJournalEntry = WorkflowRunStartedEntry | WorkflowAgentStartedEntry | WorkflowAgentCompletedEntry | WorkflowAgentFailedEntry | WorkflowRunCompletedEntry | WorkflowRunFailedEntry;
+interface WorkflowJournalEntryEnvelope {
+    readonly version: 1;
+    readonly seq: number;
+    readonly previousEntryHash: string;
+    readonly entryHash: string;
+    readonly recordedAt: string;
+    readonly taskId: string;
+    readonly runId: string;
+}
+export interface WorkflowRunStartedEntry extends WorkflowJournalEntryEnvelope {
+    readonly kind: 'workflow.run.started';
+    readonly workflowName: string;
+    readonly workflowSource: string;
+    readonly workflowSourcePath?: string;
+    readonly scriptPath: string;
+    readonly scriptHash: string;
+    readonly args: JsonValue;
+    readonly runtime: {
+        readonly schemaVersion: 1;
+        readonly cwd: string;
+    };
+}
+export interface WorkflowAgentStartedEntry extends WorkflowJournalEntryEnvelope {
+    readonly kind: 'workflow.agent.started';
+    readonly agentIndex: number;
+    readonly agentId: string;
+    readonly agentCallKey: string;
+    readonly previousAgentCallKey: string;
+    readonly prompt: string;
+    readonly semanticOpts: WorkflowAgentSemanticOpts;
+}
+export interface WorkflowAgentCompletedEntry extends WorkflowJournalEntryEnvelope {
+    readonly kind: 'workflow.agent.completed';
+    readonly agentIndex: number;
+    readonly agentId: string;
+    readonly agentCallKey: string;
+    readonly result: JsonValue;
+    readonly usage: WorkflowJournalUsage;
+    readonly toolCalls: number;
+}
+export interface WorkflowAgentFailedEntry extends WorkflowJournalEntryEnvelope {
+    readonly kind: 'workflow.agent.failed';
+    readonly agentIndex: number;
+    readonly agentId: string;
+    readonly agentCallKey: string;
+    readonly reason: string;
+    readonly message: string;
+}
+export interface WorkflowRunCompletedEntry extends WorkflowJournalEntryEnvelope {
+    readonly kind: 'workflow.run.completed';
+    readonly result: JsonValue;
+    readonly resultPath: string;
+    readonly agentCount: number;
+    readonly usage: WorkflowJournalUsage;
+    readonly toolCalls: number;
+    readonly durationMs: number;
+}
+export interface WorkflowRunFailedEntry extends WorkflowJournalEntryEnvelope {
+    readonly kind: 'workflow.run.failed';
+    readonly reason: string;
+    readonly message: string;
+    readonly recovery?: {
+        readonly retryable: boolean;
+        readonly reason: string;
+    };
+    readonly durationMs: number;
+}
+export type WorkflowJournalEntryPayload = Omit<WorkflowRunStartedEntry, keyof WorkflowJournalEntryEnvelope> | Omit<WorkflowAgentStartedEntry, keyof WorkflowJournalEntryEnvelope> | Omit<WorkflowAgentCompletedEntry, keyof WorkflowJournalEntryEnvelope> | Omit<WorkflowAgentFailedEntry, keyof WorkflowJournalEntryEnvelope> | Omit<WorkflowRunCompletedEntry, keyof WorkflowJournalEntryEnvelope> | Omit<WorkflowRunFailedEntry, keyof WorkflowJournalEntryEnvelope>;
+export interface WorkflowJournalReadResult {
+    readonly entries: readonly WorkflowJournalEntry[];
+    readonly truncatedTail: boolean;
+}
+export interface WorkflowJournalDurability {
+    readonly syncFile?: (journalPath: string, entry: WorkflowJournalEntry) => Promise<void>;
+    readonly syncDirectory?: (directoryPath: string) => Promise<void>;
+}
+export interface WorkflowJournalWriterOptions {
+    readonly transcriptDir: string;
+    readonly taskId: string;
+    readonly runId: string;
+    readonly durability?: WorkflowJournalDurability;
+}
+export declare class WorkflowJournalError extends Error {
+    readonly cause?: unknown | undefined;
+    readonly code = "workflow_journal_write_failed";
+    constructor(message: string, cause?: unknown | undefined);
+}
+export declare class WorkflowJournalValidationError extends Error {
+    readonly code = "workflow_journal_invalid";
+    constructor(message: string);
+}
+export declare class WorkflowJournalWriter {
+    private readonly options;
+    private readonly journalPath;
+    private queue;
+    private poisoned?;
+    private seq;
+    private previousEntryHash;
+    private constructor();
+    static create(options: WorkflowJournalWriterOptions): Promise<WorkflowJournalWriter>;
+    append(payload: WorkflowJournalEntryPayload): Promise<WorkflowJournalEntry>;
+    private nextEntry;
+}
+export declare const WORKFLOW_JOURNAL_GENESIS_HASH: string;
+export declare const WORKFLOW_JOURNAL_GENESIS_AGENT_CALL_KEY: string;
+export declare const WORKFLOW_JOURNAL_WRITE_FAILED_REASON = "workflow_journal_write_failed";
+export declare function workflowJournalPath(transcriptDir: string): string;
+export declare function isWorkflowJournalError(err: unknown): err is WorkflowJournalError;
+export declare function normalizeJournalJsonValue(value: unknown, label: string): JsonValue;
+export declare function stableJson(value: unknown): string;
+export declare function computeWorkflowAgentCallKey(input: {
+    readonly previousAgentCallKey: string;
+    readonly prompt: string;
+    readonly semanticOpts: WorkflowAgentSemanticOpts;
+}): string;
+export declare function workflowJournalHash(entryWithoutEntryHash: unknown): string;
+export declare function readWorkflowJournal(journalPath: string): Promise<WorkflowJournalReadResult>;
+export declare function cleanupWorkflowJournalTranscriptDir(transcriptDir: string): Promise<void>;
+export {};