bopodev-agent-sdk 0.1.11 → 0.1.13

package/dist/agent-sdk/src/adapters.d.ts

@@ -1,4 +1,5 @@
-import type { AdapterEnvironmentResult, AdapterExecutionResult, AdapterMetadata, AdapterModelOption, AgentAdapter, AgentProviderType, AgentRuntimeConfig, HeartbeatContext } from "./types";
+import type { AdapterEnvironmentCheck, AdapterEnvironmentResult, AdapterExecutionResult, AdapterMetadata, AdapterModelOption, AgentAdapter, AgentProviderType, AgentRuntimeConfig, HeartbeatContext } from "./types";
+import { type DirectApiProvider } from "./runtime-http";
 export declare class ClaudeCodeAdapter implements AgentAdapter {
     providerType: "claude_code";
     execute(context: HeartbeatContext): Promise<AdapterExecutionResult>;
@@ -15,11 +16,235 @@ export declare class OpenCodeAdapter implements AgentAdapter {
     providerType: "opencode";
     execute(context: HeartbeatContext): Promise<AdapterExecutionResult>;
 }
+export declare class OpenAIApiAdapter implements AgentAdapter {
+    providerType: "openai_api";
+    execute(context: HeartbeatContext): Promise<AdapterExecutionResult>;
+}
+export declare class AnthropicApiAdapter implements AgentAdapter {
+    providerType: "anthropic_api";
+    execute(context: HeartbeatContext): Promise<AdapterExecutionResult>;
+}
 export declare class GenericHeartbeatAdapter implements AgentAdapter {
     providerType: "http" | "shell";
     constructor(providerType: "http" | "shell");
     execute(context: HeartbeatContext): Promise<AdapterExecutionResult>;
 }
+type ProviderSessionUpdate = {
+    currentSessionId?: string | null;
+    resumedSessionId?: string | null;
+    resumeAttempted?: boolean;
+    resumeSkippedReason?: string | null;
+    clearedStaleSession?: boolean;
+    cwd?: string | null;
+};
 export declare function listAdapterMetadata(): AdapterMetadata[];
+export declare function getAdapterMetadataByProviderType(providerType: AgentProviderType): AdapterMetadata;
 export declare function listAdapterModels(providerType: AgentProviderType, runtime?: AgentRuntimeConfig): Promise<AdapterModelOption[]>;
 export declare function testAdapterEnvironment(providerType: AgentProviderType, runtime?: AgentRuntimeConfig): Promise<AdapterEnvironmentResult>;
+export declare function createSkippedResult(providerLabel: string, providerKey: string, context: HeartbeatContext): AdapterExecutionResult;
+export declare function runDirectApiWork(context: HeartbeatContext, provider: "openai_api" | "anthropic_api"): Promise<AdapterExecutionResult>;
+export declare function testDirectApiEnvironment(providerType: DirectApiProvider, runtime?: AgentRuntimeConfig): Promise<AdapterEnvironmentResult>;
+export declare function runProviderWork(context: HeartbeatContext, provider: "claude_code" | "codex", pricing: {
+    inputRate: number;
+    outputRate: number;
+}): Promise<AdapterExecutionResult>;
+export declare function runCursorWork(context: HeartbeatContext): Promise<AdapterExecutionResult>;
+export declare function runOpenCodeWork(context: HeartbeatContext): Promise<AdapterExecutionResult>;
+export declare function resolveFailedUsage(runtime: {
+    parsedUsage?: {
+        tokenInput?: number;
+        tokenOutput?: number;
+        usdCost?: number;
+        summary?: string;
+    };
+    failureType?: "timeout" | "spawn_error" | "nonzero_exit";
+    stdout: string;
+    stderr: string;
+}, prompt: string, pricing: {
+    inputRate: number;
+    outputRate: number;
+}): {
+    tokenInput: number;
+    tokenOutput: number;
+    usdCost: number;
+    source: "structured";
+} | {
+    tokenInput: number;
+    tokenOutput: number;
+    usdCost: number;
+    source: "none";
+} | {
+    tokenInput: number;
+    tokenOutput: number;
+    usdCost: number;
+    source: "estimated";
+};
+export declare function toProviderResult(context: HeartbeatContext, provider: AgentProviderType, prompt: string, runtime: {
+    ok: boolean;
+    code: number | null;
+    stdout: string;
+    stderr: string;
+    timedOut: boolean;
+    elapsedMs: number;
+    attemptCount: number;
+    failureType?: "timeout" | "spawn_error" | "nonzero_exit";
+    attempts: Array<{
+        attempt: number;
+        code: number | null;
+        timedOut: boolean;
+        elapsedMs: number;
+        signal: NodeJS.Signals | null;
+        spawnErrorCode?: string;
+        forcedKill: boolean;
+    }>;
+    parsedUsage?: {
+        tokenInput?: number;
+        tokenOutput?: number;
+        usdCost?: number;
+        summary?: string;
+    };
+    structuredOutputSource?: "stdout" | "stderr";
+    structuredOutputDiagnostics?: {
+        stdoutJsonObjectCount: number;
+        stderrJsonObjectCount: number;
+        stderrStructuredUsageDetected: boolean;
+        stdoutBytes: number;
+        stderrBytes: number;
+        hasAnyOutput: boolean;
+        lastStdoutLine?: string;
+        lastStderrLine?: string;
+        likelyCause: "no_output_from_runtime" | "json_missing" | "json_on_stderr_only" | "schema_or_shape_mismatch";
+        claudeStopReason?: string;
+        claudeResultSubtype?: string;
+        claudeSessionId?: string;
+        claudeContract?: {
+            commandOverride: boolean;
+            commandLooksClaude: boolean;
+            commandWasProviderAlias: boolean;
+            hasPromptFlag: boolean;
+            hasOutputFormatJson: boolean;
+            outputFormat: string | null;
+            hasMaxTurnsFlag: boolean;
+            hasVerboseFlag: boolean;
+            hasDangerouslySkipPermissions: boolean;
+            hasJsonSchema: boolean;
+            missingRequiredArgs: string[];
+        };
+    };
+    commandUsed?: string;
+    argsUsed?: string[];
+    transcript?: Array<{
+        kind: "system" | "assistant" | "thinking" | "tool_call" | "tool_result" | "result" | "stderr";
+        label?: string;
+        text?: string;
+        payload?: string;
+    }>;
+}, pricing: {
+    inputRate: number;
+    outputRate: number;
+}, sessionUpdate?: ProviderSessionUpdate): AdapterExecutionResult;
+export declare function resolveRuntimeFailureDetail(runtime: {
+    stderr: string;
+    stdout: string;
+    code: number | null;
+    failureType?: "timeout" | "spawn_error" | "nonzero_exit";
+    attempts: Array<{
+        spawnErrorCode?: string;
+    }>;
+}): string;
+export declare function parseOpenCodeOutput(stdout: string): {
+    sessionId: string | null;
+};
+export declare function resolveCursorResumeState(state: HeartbeatContext["state"], cwd: string): {
+    resumeSessionId: null;
+    resumeAttempted: boolean;
+    resumeSkippedReason: null;
+} | {
+    resumeSessionId: null;
+    resumeAttempted: boolean;
+    resumeSkippedReason: string;
+} | {
+    resumeSessionId: string;
+    resumeAttempted: boolean;
+    resumeSkippedReason: null;
+};
+export declare function readRuntimeSessionId(runtime: {
+    structuredOutputDiagnostics?: {
+        claudeSessionId?: string;
+        cursorSessionId?: string;
+    };
+}, fallback: string | null): string | null;
+export declare function isUnknownSessionError(stderr: string, stdout: string): boolean;
+export declare function hasTrustFlag(args: string[]): boolean;
+export declare function resolveRuntimeCommand(providerType: AgentProviderType, runtime?: AgentRuntimeConfig): string;
+export declare function runRuntimeProbe(providerType: AgentProviderType, runtime?: AgentRuntimeConfig): Promise<import("./runtime").RuntimeExecutionOutput>;
+export declare function discoverCursorModels(runtime?: AgentRuntimeConfig): Promise<AdapterModelOption[]>;
+export declare function discoverOpenCodeModels(runtime?: AgentRuntimeConfig): Promise<AdapterModelOption[]>;
+export declare function discoverOpenCodeModelsCached(runtime?: AgentRuntimeConfig): Promise<AdapterModelOption[]>;
+export declare function ensureOpenCodeModelConfiguredAndAvailable(input: {
+    model?: string;
+    command?: string;
+    cwd?: string;
+    env?: Record<string, string>;
+}): Promise<void>;
+export declare function parseModelLines(text: string): AdapterModelOption[];
+export declare function dedupeModels(models: AdapterModelOption[]): AdapterModelOption[];
+export declare function resolveCursorLaunchConfig(runtime?: AgentRuntimeConfig): Promise<{
+    command: string;
+    prefixArgs: string[];
+}>;
+export declare function toEnvironmentStatus(checks: AdapterEnvironmentCheck[]): "pass" | "warn" | "fail";
+export declare function createPrompt(context: HeartbeatContext): string;
+export declare function withProviderMetadata(context: HeartbeatContext, provider: string, lastRuntimeMs?: number, lastExitCode?: number | null): {
+    metadata: {
+        lastExitCode?: number | null | undefined;
+        lastRuntimeMs?: number | undefined;
+        lastProvider: string;
+        lastHeartbeatRunId: string;
+    };
+    sessionId?: string;
+    cwd?: string;
+    cursorSession?: {
+        sessionId: string;
+        cwd?: string;
+    };
+};
+export declare function applyProviderSessionState(context: HeartbeatContext, provider: AgentProviderType, sessionUpdate?: ProviderSessionUpdate, lastRuntimeMs?: number, lastExitCode?: number | null): import("./types").AgentState & Record<string, unknown>;
+export declare function toPreview(value: string, max?: number): string;
+export declare function buildMissingStructuredOutputDetail(provider: string, runtime: {
+    structuredOutputSource?: "stdout" | "stderr";
+    structuredOutputDiagnostics?: {
+        stdoutJsonObjectCount: number;
+        stderrJsonObjectCount: number;
+        stderrStructuredUsageDetected: boolean;
+        stdoutBytes: number;
+        stderrBytes: number;
+        hasAnyOutput: boolean;
+        lastStdoutLine?: string;
+        lastStderrLine?: string;
+        likelyCause: "no_output_from_runtime" | "json_missing" | "json_on_stderr_only" | "schema_or_shape_mismatch";
+        claudeStopReason?: string;
+        claudeResultSubtype?: string;
+        claudeSessionId?: string;
+        claudeContract?: {
+            commandOverride: boolean;
+            commandLooksClaude: boolean;
+            commandWasProviderAlias: boolean;
+            hasPromptFlag: boolean;
+            hasOutputFormatJson: boolean;
+            outputFormat: string | null;
+            hasMaxTurnsFlag: boolean;
+            hasVerboseFlag: boolean;
+            hasDangerouslySkipPermissions: boolean;
+            hasJsonSchema: boolean;
+            missingRequiredArgs: string[];
+        };
+    };
+}): string;
+export declare function isClaudeRunIncomplete(runtime: {
+    structuredOutputDiagnostics?: {
+        claudeStopReason?: string;
+        claudeResultSubtype?: string;
+    };
+}): boolean;
+export {};

package/dist/agent-sdk/src/index.d.ts

@@ -1,4 +1,6 @@
 export * from "./adapters";
 export * from "./registry";
 export * from "./runtime";
+export * from "./runtime-core";
+export * from "./runtime-parsers";
 export * from "./types";

package/dist/agent-sdk/src/registry.d.ts

@@ -1,4 +1,5 @@
-import type { AdapterEnvironmentResult, AdapterMetadata, AdapterModelOption, AgentAdapter, AgentProviderType, AgentRuntimeConfig } from "./types";
+import type { AdapterEnvironmentResult, AdapterMetadata, AdapterModule, AdapterModelOption, AgentAdapter, AgentProviderType, AgentRuntimeConfig } from "./types";
+export declare function getRegisteredAdapterModules(): Record<AgentProviderType, AdapterModule>;
 export declare function resolveAdapter(providerType: AgentProviderType): AgentAdapter;
 export declare function getAdapterModels(providerType: AgentProviderType, runtime?: AgentRuntimeConfig): Promise<AdapterModelOption[]>;
 export declare function getAdapterMetadata(): AdapterMetadata[];

package/dist/agent-sdk/src/runtime-core.d.ts

@@ -0,0 +1,2 @@
+export type { RuntimeAttemptTrace, RuntimeCommandHealth, RuntimeExecutionOutput, RuntimeTranscriptEvent } from "./runtime";
+export { checkRuntimeCommandHealth, executeAgentRuntime, executePromptRuntime } from "./runtime";

package/dist/agent-sdk/src/runtime-http.d.ts

@@ -0,0 +1,38 @@
+import type { AgentRuntimeConfig } from "./types";
+export type DirectApiProvider = "openai_api" | "anthropic_api";
+export type DirectApiExecutionOutput = {
+    ok: boolean;
+    provider: DirectApiProvider;
+    model: string;
+    endpoint: string;
+    elapsedMs: number;
+    statusCode: number;
+    summary?: string;
+    tokenInput?: number;
+    tokenOutput?: number;
+    usdCost?: number;
+    failureType?: "auth" | "rate_limit" | "timeout" | "network" | "bad_response" | "http_error";
+    error?: string;
+    responsePreview?: string;
+    attemptCount: number;
+    attempts: Array<{
+        attempt: number;
+        statusCode: number;
+        elapsedMs: number;
+        failureType?: "auth" | "rate_limit" | "timeout" | "network" | "bad_response" | "http_error";
+        error?: string;
+    }>;
+};
+type ProbeResult = {
+    ok: boolean;
+    statusCode: number;
+    elapsedMs: number;
+    message: string;
+};
+export declare function resolveDirectApiCredentials(provider: DirectApiProvider, runtime?: AgentRuntimeConfig): {
+    key: string;
+    baseUrl: string;
+};
+export declare function executeDirectApiRuntime(provider: DirectApiProvider, prompt: string, runtime?: AgentRuntimeConfig): Promise<DirectApiExecutionOutput>;
+export declare function probeDirectApiEnvironment(provider: DirectApiProvider, runtime?: AgentRuntimeConfig): Promise<ProbeResult>;
+export {};

package/dist/agent-sdk/src/runtime-parsers.d.ts

@@ -0,0 +1 @@
+export { parseClaudeStreamOutput, parseCursorStreamOutput, parseRuntimeTranscript, parseStructuredUsage } from "./runtime";

package/dist/agent-sdk/src/runtime.d.ts

@@ -13,6 +13,20 @@ type ClaudeContractDiagnostics = {
     hasJsonSchema: boolean;
     missingRequiredArgs: string[];
 };
+type ParsedUsageRecord = {
+    tokenInput?: number;
+    tokenOutput?: number;
+    usdCost?: number;
+    summary?: string;
+};
+type CursorParsedStream = {
+    usage: ParsedUsageRecord;
+    sessionId?: string;
+    errorMessage?: string;
+    resultSubtype?: string;
+};
+type TranscriptSignalLevel = "high" | "medium" | "low" | "noise";
+type TranscriptSource = "stdout" | "stderr" | "trace_fallback";
 export interface RuntimeExecutionOutput {
     ok: boolean;
     code: number | null;
@@ -54,6 +68,9 @@ export interface RuntimeTranscriptEvent {
     label?: string;
     text?: string;
     payload?: string;
+    signalLevel?: TranscriptSignalLevel;
+    groupKey?: string;
+    source?: TranscriptSource;
 }
 export interface RuntimeAttemptTrace {
     attempt: number;
@@ -80,4 +97,23 @@ export declare function checkRuntimeCommandHealth(command: string, options?: {
     cwd?: string;
     timeoutMs?: number;
 }): Promise<RuntimeCommandHealth>;
+export declare function parseStructuredUsage(stdout: string): {
+    tokenInput: number | undefined;
+    tokenOutput: number | undefined;
+    usdCost: number | undefined;
+    summary: string | undefined;
+} | undefined;
+export declare function parseClaudeStreamOutput(stdout: string): {
+    usage: {
+        summary: string | undefined;
+        tokenInput: number | undefined;
+        tokenOutput: number | undefined;
+        usdCost: number | undefined;
+    };
+    stopReason: string | undefined;
+    resultSubtype: string | undefined;
+    sessionId: string | undefined;
+} | undefined;
+export declare function parseCursorStreamOutput(stdout: string): CursorParsedStream | undefined;
+export declare function parseRuntimeTranscript(provider: LocalProvider | undefined, stdout: string, stderr: string): RuntimeTranscriptEvent[] | undefined;
 export {};

package/dist/agent-sdk/src/types.d.ts

@@ -10,6 +10,14 @@ export interface AgentWorkItem {
     priority?: string;
     labels?: string[];
     tags?: string[];
+    attachments?: Array<{
+        id: string;
+        fileName: string;
+        mimeType?: string | null;
+        fileSizeBytes: number;
+        relativePath: string;
+        absolutePath: string;
+    }>;
 }
 export interface AgentState {
     sessionId?: string;
@@ -20,6 +28,12 @@ export interface AgentState {
     };
     metadata?: Record<string, unknown>;
 }
+export interface AgentMemoryContext {
+    memoryRoot: string;
+    tacitNotes?: string;
+    durableFacts: string[];
+    dailyNotes: string[];
+}
 export interface HeartbeatContext {
     companyId: string;
     agentId: string;
@@ -41,6 +55,7 @@ export interface HeartbeatContext {
         agentGoals: string[];
     };
     state: AgentState;
+    memoryContext?: AgentMemoryContext;
     runtime?: AgentRuntimeConfig;
 }
 export interface AdapterExecutionResult {
@@ -57,6 +72,11 @@ export interface AgentAdapter {
     providerType: AgentProviderType;
     execute(context: HeartbeatContext): Promise<AdapterExecutionResult>;
 }
+export interface AdapterSessionCodec {
+    deserialize(raw: unknown): Record<string, unknown> | null;
+    serialize(params: Record<string, unknown> | null): Record<string, unknown> | null;
+    getDisplayId?(params: Record<string, unknown> | null): string | null;
+}
 export type AdapterEnvironmentCheckLevel = "info" | "warn" | "error";
 export type AdapterEnvironmentStatus = "pass" | "warn" | "fail";
 export interface AdapterEnvironmentCheck {
@@ -85,6 +105,32 @@ export interface AdapterMetadata {
     supportsThinkingEffort: boolean;
     requiresRuntimeCwd: boolean;
 }
+export interface ServerAdapterModule {
+    type: AgentProviderType;
+    execute(context: HeartbeatContext): Promise<AdapterExecutionResult>;
+    listModels?(runtime?: AgentRuntimeConfig): Promise<AdapterModelOption[]>;
+    testEnvironment?(runtime?: AgentRuntimeConfig): Promise<AdapterEnvironmentResult>;
+    sessionCodec?: AdapterSessionCodec;
+}
+export interface UIAdapterModule {
+    type: AgentProviderType;
+    parseStdoutLine?: (line: string, timestampIso: string) => Array<Record<string, unknown>>;
+    buildAdapterConfig?: (values: Record<string, unknown>) => Record<string, unknown>;
+}
+export interface CLIAdapterModule {
+    type: AgentProviderType;
+    formatStdoutEvent?: (line: string, debug: boolean) => void;
+}
+export interface AdapterModule {
+    type: AgentProviderType;
+    label: string;
+    metadata: AdapterMetadata;
+    models?: AdapterModelOption[];
+    agentConfigurationDoc?: string;
+    server: ServerAdapterModule;
+    ui?: UIAdapterModule;
+    cli?: CLIAdapterModule;
+}
 export interface AgentRuntimeConfig {
     command?: string;
     args?: string[];
@@ -102,6 +148,15 @@ export interface AgentRuntimeConfig {
         sandboxMode?: "workspace_write" | "full_access";
         allowWebSearch?: boolean;
     };
+    onTranscriptEvent?: (event: {
+        kind: "system" | "assistant" | "thinking" | "tool_call" | "tool_result" | "result" | "stderr";
+        label?: string;
+        text?: string;
+        payload?: string;
+        signalLevel?: "high" | "medium" | "low" | "noise";
+        groupKey?: string;
+        source?: "stdout" | "stderr" | "trace_fallback";
+    }) => void;
 }
 export interface AdapterTrace {
     command?: string;