@crewx/sdk 0.9.0-rc.17 → 0.9.0-rc.170

package/dist/agent-interceptor/schema.d.ts

@@ -0,0 +1,267 @@
+import { z } from 'zod';
+import { type AgentInterceptorItem } from './types';
+export declare const AGENT_INTERCEPTOR_SCHEMA_VERSION = 1;
+export declare const AGENT_INTERCEPTOR_DEFAULT_TIMEOUT_MS = 10000;
+export declare const AGENT_INTERCEPTOR_MAX_TIMEOUT_MS = 120000;
+export declare const AgentInterceptorItemSchema: z.ZodEffects<z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodEnum<["mutation", "validation"]>;
+    phase: z.ZodEnum<["request", "response"]>;
+    mode: z.ZodDefault<z.ZodEnum<["active", "audit"]>>;
+    failOpen: z.ZodDefault<z.ZodBoolean>;
+    priorityHint: z.ZodDefault<z.ZodNumber>;
+    timeoutMs: z.ZodDefault<z.ZodNumber>;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    config: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    command: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    model: z.ZodOptional<z.ZodObject<{
+        provider: z.ZodString;
+        model: z.ZodOptional<z.ZodString>;
+        instruction: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        provider: string;
+        instruction: string;
+        model?: string | undefined;
+    }, {
+        provider: string;
+        instruction: string;
+        model?: string | undefined;
+    }>>;
+}, "strict", z.ZodTypeAny, {
+    name: string;
+    mode: "active" | "audit";
+    type: "mutation" | "validation";
+    config: Record<string, unknown>;
+    enabled: boolean;
+    timeoutMs: number;
+    phase: "request" | "response";
+    failOpen: boolean;
+    priorityHint: number;
+    model?: {
+        provider: string;
+        instruction: string;
+        model?: string | undefined;
+    } | undefined;
+    command?: string[] | undefined;
+}, {
+    name: string;
+    type: "mutation" | "validation";
+    phase: "request" | "response";
+    mode?: "active" | "audit" | undefined;
+    model?: {
+        provider: string;
+        instruction: string;
+        model?: string | undefined;
+    } | undefined;
+    command?: string[] | undefined;
+    config?: Record<string, unknown> | undefined;
+    enabled?: boolean | undefined;
+    timeoutMs?: number | undefined;
+    failOpen?: boolean | undefined;
+    priorityHint?: number | undefined;
+}>, {
+    name: string;
+    mode: "active" | "audit";
+    type: "mutation" | "validation";
+    config: Record<string, unknown>;
+    enabled: boolean;
+    timeoutMs: number;
+    phase: "request" | "response";
+    failOpen: boolean;
+    priorityHint: number;
+    model?: {
+        provider: string;
+        instruction: string;
+        model?: string | undefined;
+    } | undefined;
+    command?: string[] | undefined;
+}, {
+    name: string;
+    type: "mutation" | "validation";
+    phase: "request" | "response";
+    mode?: "active" | "audit" | undefined;
+    model?: {
+        provider: string;
+        instruction: string;
+        model?: string | undefined;
+    } | undefined;
+    command?: string[] | undefined;
+    config?: Record<string, unknown> | undefined;
+    enabled?: boolean | undefined;
+    timeoutMs?: number | undefined;
+    failOpen?: boolean | undefined;
+    priorityHint?: number | undefined;
+}>;
+export declare const AgentInterceptorChainSchema: z.ZodEffects<z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    items: z.ZodArray<z.ZodEffects<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodEnum<["mutation", "validation"]>;
+        phase: z.ZodEnum<["request", "response"]>;
+        mode: z.ZodDefault<z.ZodEnum<["active", "audit"]>>;
+        failOpen: z.ZodDefault<z.ZodBoolean>;
+        priorityHint: z.ZodDefault<z.ZodNumber>;
+        timeoutMs: z.ZodDefault<z.ZodNumber>;
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        config: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        command: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        model: z.ZodOptional<z.ZodObject<{
+            provider: z.ZodString;
+            model: z.ZodOptional<z.ZodString>;
+            instruction: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            provider: string;
+            instruction: string;
+            model?: string | undefined;
+        }, {
+            provider: string;
+            instruction: string;
+            model?: string | undefined;
+        }>>;
+    }, "strict", z.ZodTypeAny, {
+        name: string;
+        mode: "active" | "audit";
+        type: "mutation" | "validation";
+        config: Record<string, unknown>;
+        enabled: boolean;
+        timeoutMs: number;
+        phase: "request" | "response";
+        failOpen: boolean;
+        priorityHint: number;
+        model?: {
+            provider: string;
+            instruction: string;
+            model?: string | undefined;
+        } | undefined;
+        command?: string[] | undefined;
+    }, {
+        name: string;
+        type: "mutation" | "validation";
+        phase: "request" | "response";
+        mode?: "active" | "audit" | undefined;
+        model?: {
+            provider: string;
+            instruction: string;
+            model?: string | undefined;
+        } | undefined;
+        command?: string[] | undefined;
+        config?: Record<string, unknown> | undefined;
+        enabled?: boolean | undefined;
+        timeoutMs?: number | undefined;
+        failOpen?: boolean | undefined;
+        priorityHint?: number | undefined;
+    }>, {
+        name: string;
+        mode: "active" | "audit";
+        type: "mutation" | "validation";
+        config: Record<string, unknown>;
+        enabled: boolean;
+        timeoutMs: number;
+        phase: "request" | "response";
+        failOpen: boolean;
+        priorityHint: number;
+        model?: {
+            provider: string;
+            instruction: string;
+            model?: string | undefined;
+        } | undefined;
+        command?: string[] | undefined;
+    }, {
+        name: string;
+        type: "mutation" | "validation";
+        phase: "request" | "response";
+        mode?: "active" | "audit" | undefined;
+        model?: {
+            provider: string;
+            instruction: string;
+            model?: string | undefined;
+        } | undefined;
+        command?: string[] | undefined;
+        config?: Record<string, unknown> | undefined;
+        enabled?: boolean | undefined;
+        timeoutMs?: number | undefined;
+        failOpen?: boolean | undefined;
+        priorityHint?: number | undefined;
+    }>, "many">;
+}, "strict", z.ZodTypeAny, {
+    schemaVersion: 1;
+    items: {
+        name: string;
+        mode: "active" | "audit";
+        type: "mutation" | "validation";
+        config: Record<string, unknown>;
+        enabled: boolean;
+        timeoutMs: number;
+        phase: "request" | "response";
+        failOpen: boolean;
+        priorityHint: number;
+        model?: {
+            provider: string;
+            instruction: string;
+            model?: string | undefined;
+        } | undefined;
+        command?: string[] | undefined;
+    }[];
+}, {
+    schemaVersion: 1;
+    items: {
+        name: string;
+        type: "mutation" | "validation";
+        phase: "request" | "response";
+        mode?: "active" | "audit" | undefined;
+        model?: {
+            provider: string;
+            instruction: string;
+            model?: string | undefined;
+        } | undefined;
+        command?: string[] | undefined;
+        config?: Record<string, unknown> | undefined;
+        enabled?: boolean | undefined;
+        timeoutMs?: number | undefined;
+        failOpen?: boolean | undefined;
+        priorityHint?: number | undefined;
+    }[];
+}>, {
+    schemaVersion: 1;
+    items: {
+        name: string;
+        mode: "active" | "audit";
+        type: "mutation" | "validation";
+        config: Record<string, unknown>;
+        enabled: boolean;
+        timeoutMs: number;
+        phase: "request" | "response";
+        failOpen: boolean;
+        priorityHint: number;
+        model?: {
+            provider: string;
+            instruction: string;
+            model?: string | undefined;
+        } | undefined;
+        command?: string[] | undefined;
+    }[];
+}, {
+    schemaVersion: 1;
+    items: {
+        name: string;
+        type: "mutation" | "validation";
+        phase: "request" | "response";
+        mode?: "active" | "audit" | undefined;
+        model?: {
+            provider: string;
+            instruction: string;
+            model?: string | undefined;
+        } | undefined;
+        command?: string[] | undefined;
+        config?: Record<string, unknown> | undefined;
+        enabled?: boolean | undefined;
+        timeoutMs?: number | undefined;
+        failOpen?: boolean | undefined;
+        priorityHint?: number | undefined;
+    }[];
+}>;
+export declare class AgentInterceptorConfigError extends Error {
+    readonly code = "INTERCEPTOR_CONFIG_INVALID";
+    constructor(agentId: string, message: string);
+}
+export declare function parseAgentInterceptorItems(agentId: string, raw: unknown): AgentInterceptorItem[] | undefined;

package/dist/agent-interceptor/types.d.ts

@@ -0,0 +1,88 @@
+export type InterceptorPhase = 'request' | 'response';
+export type InterceptorType = 'mutation' | 'validation';
+export type InterceptorMode = 'active' | 'audit';
+export type InterceptorSeverity = 'error' | 'warn' | 'info';
+export type InterceptorOutcome = 'applied' | 'unchanged' | 'blocked' | 'audit' | 'bypassed' | 'failed';
+export declare const INTERCEPTOR_CONFIG_INVALID = "INTERCEPTOR_CONFIG_INVALID";
+export declare const INTERCEPTOR_BLOCKED = "INTERCEPTOR_BLOCKED";
+export declare const INTERCEPTOR_STOPPED = "INTERCEPTOR_STOPPED";
+export declare const INTERCEPTOR_FAILED = "INTERCEPTOR_FAILED";
+export interface AgentInterceptorItem {
+    name: string;
+    type: InterceptorType;
+    phase: InterceptorPhase;
+    mode: InterceptorMode;
+    failOpen: boolean;
+    priorityHint: number;
+    timeoutMs: number;
+    enabled: boolean;
+    config: Record<string, unknown>;
+    command?: string[];
+    model?: {
+        provider: string;
+        model?: string;
+        instruction: string;
+    };
+}
+export interface InterceptorMessage {
+    role: string;
+    content: string;
+}
+export interface InterceptorVerdict {
+    valid: boolean;
+    severity?: InterceptorSeverity;
+    messages: Array<{
+        message: string;
+    }>;
+}
+export interface InterceptorError {
+    code: number | string;
+    message: string;
+}
+export interface InterceptorUsage {
+    inputTokens: number;
+    outputTokens: number;
+    cachedInputTokens: number;
+    costUsd: number;
+}
+export interface InterceptorStepLog {
+    name: string;
+    type: InterceptorType;
+    phase: InterceptorPhase;
+    mode: InterceptorMode;
+    outcome: InterceptorOutcome;
+    failOpen: boolean;
+    durationMs: number;
+    error?: InterceptorError;
+    before: string;
+    after?: string;
+    verdict?: InterceptorVerdict;
+    usage?: InterceptorUsage;
+    stderr?: string;
+}
+export type InterceptorInvocation = {
+    ok: true;
+    result: unknown;
+    durationMs: number;
+    usage?: InterceptorUsage;
+    stderr?: string;
+} | {
+    ok: false;
+    code: number | string;
+    message: string;
+    durationMs: number;
+    usage?: InterceptorUsage;
+    stderr?: string;
+};
+export interface InterceptorLaneRun {
+    phase: InterceptorPhase;
+    status: 'passed' | 'blocked' | 'stopped';
+    text: string;
+    changed: boolean;
+    steps: InterceptorStepLog[];
+    blocked?: {
+        step: string;
+        code: typeof INTERCEPTOR_BLOCKED;
+        message: string;
+    };
+}

package/dist/app/app.d.ts

@@ -0,0 +1,167 @@
+import type { UiContentMediaType } from './content-media-types.js';
+import type { AppScheduleDirective, AppScheduleSnapshot, ToolScheduleDeclaration } from './schedule-contract.js';
+import type { AppJobOperation, ToolJobDeclaration } from './job-contract.js';
+import type { AppJobRun, AppJobs } from './job-bridge.js';
+export type JsonObject = Record<string, unknown>;
+export type JsonSchema = Readonly<{
+    type: 'object';
+    properties: Readonly<Record<string, unknown>>;
+    required: readonly string[];
+    additionalProperties: false;
+}>;
+export type ToolResult = void | JsonObject | Promise<void | JsonObject>;
+export interface AppDefinition {
+    readonly manifestVersion: 2;
+    readonly pluginId: string;
+    readonly definitionId: string;
+    readonly version: number;
+    readonly name: string;
+    readonly description: string;
+    readonly icon?: string;
+    readonly tone?: string;
+    readonly entry: string;
+    readonly initialState: Readonly<{
+        path: string;
+    }>;
+    readonly dataPaths?: readonly string[];
+    readonly surfaces: readonly string[];
+    readonly size?: Readonly<Record<string, number>>;
+    readonly stateProjection: Readonly<{
+        allow: readonly string[];
+    }>;
+}
+export interface ToolContentInput {
+    readonly mediaType: UiContentMediaType;
+    readonly required?: boolean;
+}
+export interface ToolContentOutput {
+    readonly mediaType: UiContentMediaType;
+    readonly range?: boolean;
+}
+export interface ToolContentDeclaration {
+    readonly in?: ToolContentInput;
+    readonly out?: ToolContentOutput;
+}
+export interface ContentRangeRequest {
+    readonly startLine: number;
+    readonly lineCount: number;
+}
+export interface ContentRange extends ContentRangeRequest {
+    readonly totalLines: number;
+}
+export interface ToolContent {
+    readonly in?: {
+        readonly text: string;
+    };
+    readonly out?: {
+        readonly range?: ContentRangeRequest;
+    };
+}
+export interface ToolOptions {
+    readonly name: string;
+    readonly description: string;
+    readonly inputSchema: JsonSchema;
+    readonly capability?: string;
+    readonly confirmation?: string;
+    readonly mutation?: boolean;
+    readonly dataInputs?: readonly string[];
+    readonly resultProjection?: Readonly<{
+        allow: readonly string[];
+    }>;
+    readonly content?: ToolContentDeclaration;
+    readonly schedule?: ToolScheduleDeclaration;
+    readonly job?: ToolJobDeclaration;
+    readonly jobAccess?: readonly AppJobOperation[];
+}
+export interface AppContext {
+    readonly instanceId: string;
+    readonly threadId: string | null;
+    readonly actor: 'user' | 'agent' | 'schedule';
+    readonly requestId: string;
+    readonly nowMs: number;
+}
+export interface AppRuntimeOptions<State extends JsonObject = JsonObject> {
+    readonly state?: State;
+    readonly workspaceRoot: string;
+    readonly context?: AppContext;
+    readonly schedule?: AppScheduleSnapshot;
+    readonly jobs?: AppJobs;
+    readonly jobRun?: AppJobRun;
+}
+export type AppFailureOutcome = 'failed' | 'rejected';
+export interface AppErrorMapping {
+    readonly code: string;
+    readonly detail: string | null;
+    readonly outcome?: AppFailureOutcome;
+}
+export interface AppErrorOptions {
+    readonly outcome?: AppFailureOutcome;
+}
+export interface AppErrorContext {
+    readonly input: unknown;
+    readonly state: unknown;
+}
+export type DeepReadonly<T> = T extends (...args: never[]) => unknown ? T : T extends readonly (infer Item)[] ? readonly DeepReadonly<Item>[] : T extends object ? {
+    readonly [Key in keyof T]: DeepReadonly<T[Key]>;
+} : T;
+export declare class AppError extends Error {
+    readonly code: string;
+    readonly detail: string | null;
+    readonly outcome: AppFailureOutcome;
+    constructor(code: string, detail?: string | null, options?: AppErrorOptions);
+}
+export declare function normalizeFailureOutcome(value: unknown): AppFailureOutcome;
+export declare class CrewXApp<State extends JsonObject = JsonObject> {
+    static readonly devtools: {
+        readonly log: boolean;
+    } | undefined;
+    private currentState;
+    private stateWasSet;
+    private answerBody;
+    private answerRange;
+    private readonly callContext;
+    private readonly callSchedule;
+    private readonly callJobs;
+    private readonly callJobRun;
+    private scheduleDirective;
+    readonly workspaceRoot: string;
+    constructor(options?: AppRuntimeOptions<State>);
+    get jobs(): AppJobs | undefined;
+    get jobRun(): AppJobRun | undefined;
+    get schedule(): AppScheduleSnapshot | undefined;
+    requestSchedule(enabled: boolean): void;
+    get didRequestSchedule(): AppScheduleDirective | undefined;
+    get context(): AppContext;
+    get state(): DeepReadonly<State>;
+    get didSetState(): boolean;
+    setState(next: State): void;
+    get didSetContent(): boolean;
+    get producedContent(): {
+        readonly body: Uint8Array;
+        readonly range?: ContentRange;
+    } | undefined;
+    setContent(body: string | Uint8Array, range?: ContentRange): void;
+    emptyState(): State;
+    validate(_actionId: string, _input: JsonObject, _state: JsonObject): void | Promise<void>;
+    mapError(_error: unknown): AppErrorMapping;
+    errorState(code: string, detail: string | null, context: AppErrorContext): State;
+}
+export interface ToolDeclaration {
+    readonly methodName: string;
+    readonly options: ToolOptions;
+}
+export type CrewXAppConstructor = (new (options: AppRuntimeOptions) => CrewXApp) & {
+    readonly devtools?: {
+        readonly log?: boolean;
+    };
+    readonly definition: AppDefinition;
+    readonly [key: string]: unknown;
+};
+type DecoratedMethod<This, Input extends object, Result extends ToolResult> = (this: This, input: Input, content: ToolContent) => Result;
+export declare function Tool(options: ToolOptions): <This, Input extends object, Result extends ToolResult>(_method: DecoratedMethod<This, Input, Result>, context: ClassMethodDecoratorContext<This, DecoratedMethod<This, Input, Result>>) => void;
+export declare function getToolDeclarations(appClass: CrewXAppConstructor): ToolDeclaration[];
+export declare function declaresSchedule(appClass: CrewXAppConstructor): boolean;
+export declare function generateToolDeclarations(appClass: CrewXAppConstructor): JsonObject[];
+export declare function generateManifest(appClass: CrewXAppConstructor, backendCommand: readonly string[]): JsonObject;
+export declare function isPlainRecord(value: unknown): value is JsonObject;
+export {};

package/dist/app/backend-env.d.ts

@@ -0,0 +1,3 @@
+export declare const SKILL_BACKEND_ENV_NAMES: readonly ["CREWX_APP_INSTANCE_ID", "CREWX_THREAD_ID"];
+export type SkillBackendEnvName = (typeof SKILL_BACKEND_ENV_NAMES)[number];
+export declare function isSkillBackendEnv(value: unknown): value is readonly SkillBackendEnvName[];

package/dist/app/content-media-types.d.ts

@@ -0,0 +1,2 @@
+export declare const UI_CONTENT_MEDIA_TYPES: readonly ["text/plain", "application/json"];
+export type UiContentMediaType = (typeof UI_CONTENT_MEDIA_TYPES)[number];

package/dist/app/context.d.ts

@@ -0,0 +1,2 @@
+import type { AppContext } from './app.js';
+export declare function readAppContext(env?: NodeJS.ProcessEnv): AppContext | undefined;

package/dist/app/entry.d.ts

@@ -0,0 +1,9 @@
+import type { JsonObject } from './app.js';
+import type { RunSkillAppOptions } from './runtime.js';
+export interface AppEntryOptions {
+    readonly sanitize?: (value: unknown) => unknown;
+    readonly emptyState?: JsonObject;
+    readonly inputFd?: number;
+    readonly jobBridge?: RunSkillAppOptions['jobBridge'];
+}
+export declare function runAppEntry(importApp: () => Promise<unknown>, options?: AppEntryOptions): Promise<void>;

package/dist/app/frame.d.ts

@@ -0,0 +1,55 @@
+import type { ContentRange, ContentRangeRequest, JsonObject } from './app.js';
+import type { UiContentMediaType } from './protocol.js';
+export declare const MAX_REQUEST_BYTES: number;
+export type RequestFrame = {
+    readonly kind: 'v1';
+    readonly value: unknown;
+} | {
+    readonly kind: 'v2';
+    readonly header: JsonObject;
+    readonly body: Uint8Array;
+} | {
+    readonly kind: 'invalid';
+};
+export declare function readStdinBytes(fd: number, maxBytes: number): Uint8Array | undefined;
+export declare function readRequestFrame(fd: number): RequestFrame;
+export declare function parseRequestFrame(bytes: Uint8Array | undefined): RequestFrame;
+export interface ContentRequest {
+    readonly in?: {
+        readonly mediaType: UiContentMediaType;
+        readonly text: string;
+    };
+    readonly out?: {
+        readonly mediaType: UiContentMediaType;
+        readonly range?: ContentRangeRequest;
+    };
+}
+export interface VerifiedFrame {
+    readonly actionId: string;
+    readonly input: JsonObject;
+    readonly state: JsonObject;
+    readonly content: ContentRequest;
+}
+export interface FrameFailure {
+    readonly code: string;
+    readonly outcome: 'failed' | 'rejected';
+}
+export declare function verifyRequestFrame(header: JsonObject, body: Uint8Array): VerifiedFrame | FrameFailure;
+export declare function isFrameFailure(value: VerifiedFrame | FrameFailure): value is FrameFailure;
+export interface DeclaredContent {
+    readonly in?: {
+        readonly mediaType: UiContentMediaType;
+        readonly required?: boolean;
+    };
+    readonly out?: {
+        readonly mediaType: UiContentMediaType;
+        readonly range?: boolean;
+    };
+}
+export declare function checkAgainstDeclaration(declared: DeclaredContent | undefined, request: ContentRequest): FrameFailure | undefined;
+export interface AnswerContent {
+    readonly body: Uint8Array;
+    readonly range?: ContentRange;
+}
+export declare function encodeResponseFrame(header: JsonObject, answer?: AnswerContent): Uint8Array;
+export declare function answerLimitFailure(answer: AnswerContent): FrameFailure | undefined;

package/dist/app/index.d.ts

@@ -0,0 +1,18 @@
+export { AppError, CrewXApp, Tool, generateManifest, generateToolDeclarations, getToolDeclarations, } from './app.js';
+export type { AppContext, AppDefinition, AppErrorContext, AppErrorMapping, AppErrorOptions, AppFailureOutcome, AppRuntimeOptions, ContentRange, ContentRangeRequest, CrewXAppConstructor, DeepReadonly, JsonObject, JsonSchema, ToolContent, ToolContentDeclaration, ToolContentInput, ToolContentOutput, ToolDeclaration, ToolOptions, ToolResult, } from './app.js';
+export { readAppContext } from './context.js';
+export { APP_SCHEDULE_ACTOR_KIND, APP_SCHEDULE_INERT_COMMAND, APP_SCHEDULE_INSTANCE_PREFIX, APP_SCHEDULE_INTERVALS_MINUTES, APP_SCHEDULE_MAX_PER_APP, APP_SCHEDULE_PERIODIC_REASONS, APP_SCHEDULE_TIMEOUT_MS, SCHEDULE_TRIGGERS, isAppSchedulePeriodicReason, isAppScheduleCode, isAppScheduleIntervalMinutes, isAppScheduleTimeoutMs, } from './schedule-contract.js';
+export type { AppScheduleDirective, AppScheduleIntervalMinutes, AppSchedulePeriodic, AppSchedulePeriodicReason, AppScheduleRunVerdict, AppScheduleSnapshot, AppScheduleStatus, ScheduleTrigger, ToolScheduleDeclaration, } from './schedule-contract.js';
+export { APP_TOOLS_FILE, APP_TOOLS_SCHEMA_VERSION, APP_TOOL_ENTRY } from './tool-mode.js';
+export { SKILL_BACKEND_ENV_NAMES, isSkillBackendEnv } from './backend-env.js';
+export type { SkillBackendEnvName } from './backend-env.js';
+export { executeAppRequest, runSkillApp } from './runtime.js';
+export type { AppFailureInfo, RunSkillAppOptions } from './runtime.js';
+export { runAppEntry } from './entry.js';
+export type { AppEntryOptions } from './entry.js';
+export { APP_JOB_CAPABILITY, APP_JOB_CAPABILITY_VERSION, APP_JOB_DEADLINE_MS, APP_JOB_MAX_PER_APP, APP_JOB_OPERATIONS, APP_JOB_OUTCOMES, APP_JOB_RUN_REQUIRED, APP_JOB_REFUSAL_CODES, APP_JOB_STATES, APP_JOB_STOP_GRACE_MS, APP_JOB_STOP_REASONS, APP_JOB_TRIGGERS, hasAppJobCapability, isAppJobCode, isAppJobDeadlineMs, isAppJobOperation, isAppJobPhase, } from './job-contract.js';
+export type { AppJobCapabilityDeclaration, AppJobOperation, AppJobOutcome, AppJobRefusalCode, AppJobState, AppJobStopReason, AppJobTrigger, ToolJobDeclaration, } from './job-contract.js';
+export { APP_JOB_BRIDGE_CHANNEL_MAX_BYTES, APP_JOB_BRIDGE_DRAIN_TIMEOUT_MS, APP_JOB_BRIDGE_ENV, APP_JOB_BRIDGE_ERROR_CODES, APP_JOB_BRIDGE_FD, APP_JOB_BRIDGE_MAX_LINE_BYTES, APP_JOB_BRIDGE_REPLY_TIMEOUT_MS, APP_JOB_BRIDGE_VERSION, AppJobLineReader, appJobTriggerForActor, buildAppJobChannelEnvironment, encodeAppJobLine, parseAppJobChannel, parseAppJobControlReply, parseAppJobControlRequest, parseAppJobRunPush, parseAppJobRunReport, parseAppJobView, readAppJobChannel, } from './job-wire.js';
+export type { AppJobBridgeErrorCode, AppJobChannel, AppJobControlReply, AppJobControlRequest, AppJobLineEvent, AppJobRunPush, AppJobRunReport, AppJobView, AppJobWireHandle, } from './job-wire.js';
+export { AppJobBridge, openInheritedAppJobTransport } from './job-bridge.js';
+export type { AppJobBridgeOptions, AppJobLineTransport, AppJobProgress, AppJobRun, AppJobStartOutcome, AppJobStatusOutcome, AppJobStopOutcome, AppJobs, AppJobTransportOpener, } from './job-bridge.js';