@crewx/sdk 0.9.0-rc.2 → 0.9.0-rc.200

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: "response" | "request";
+    failOpen: boolean;
+    priorityHint: number;
+    model?: {
+        provider: string;
+        instruction: string;
+        model?: string | undefined;
+    } | undefined;
+    command?: string[] | undefined;
+}, {
+    name: string;
+    type: "mutation" | "validation";
+    phase: "response" | "request";
+    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: "response" | "request";
+    failOpen: boolean;
+    priorityHint: number;
+    model?: {
+        provider: string;
+        instruction: string;
+        model?: string | undefined;
+    } | undefined;
+    command?: string[] | undefined;
+}, {
+    name: string;
+    type: "mutation" | "validation";
+    phase: "response" | "request";
+    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: "response" | "request";
+        failOpen: boolean;
+        priorityHint: number;
+        model?: {
+            provider: string;
+            instruction: string;
+            model?: string | undefined;
+        } | undefined;
+        command?: string[] | undefined;
+    }, {
+        name: string;
+        type: "mutation" | "validation";
+        phase: "response" | "request";
+        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: "response" | "request";
+        failOpen: boolean;
+        priorityHint: number;
+        model?: {
+            provider: string;
+            instruction: string;
+            model?: string | undefined;
+        } | undefined;
+        command?: string[] | undefined;
+    }, {
+        name: string;
+        type: "mutation" | "validation";
+        phase: "response" | "request";
+        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: "response" | "request";
+        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: "response" | "request";
+        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: "response" | "request";
+        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: "response" | "request";
+        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-files/args.d.ts

@@ -0,0 +1,12 @@
+export declare const APP_FILES_LIMITS: {
+    readonly textBytes: number;
+    readonly refCodePoints: 200;
+    readonly refSegments: 3;
+    readonly pageSize: 200;
+};
+export declare const APP_FILES_SEGMENT: RegExp;
+export declare function normalizeAppFilesRef(ref: string): string | undefined;
+export declare function checkAppFilesRef(ref: unknown): string;
+export declare function checkAppFilesPrefix(prefix: unknown): string;
+export declare function checkAppFilesText(text: unknown): string;
+export declare function checkAppFilesExpectedVersion(value: unknown): string | null;

package/dist/app/app-files/errors.d.ts

@@ -0,0 +1,6 @@
+export declare const APP_FILES_ERROR_CODES: readonly ["INVALID_REF", "FILE_NOT_FOUND", "DOCUMENT_CHANGED", "TOO_LARGE", "IO_ERROR", "FILE_BUSY"];
+export type AppFilesErrorCode = (typeof APP_FILES_ERROR_CODES)[number];
+export declare class AppFilesError extends Error {
+    readonly code: AppFilesErrorCode;
+    constructor(code: AppFilesErrorCode);
+}

package/dist/app/app-files/index.d.ts

@@ -0,0 +1,35 @@
+import { type AppFilesInstallOrigin, type AppFilesSource } from './root.js';
+import { type AppFilesListItem, type AppFilesPage, type AppFilesRead, type AppFilesWritten } from './store.js';
+export { APP_FILES_ERROR_CODES, AppFilesError, type AppFilesErrorCode } from './errors.js';
+export { APP_FILES_LIMITS, normalizeAppFilesRef } from './args.js';
+export type { AppFilesInstallOrigin, AppFilesSource } from './root.js';
+export type { AppFilesListItem, AppFilesPage, AppFilesRead, AppFilesWritten } from './store.js';
+export { appFilesLockKeyOf } from './store.js';
+export { appFilesRootSegmentsOf } from './root.js';
+export { APP_FILES_LOCK_SUBPATH, acquireFileLock, releaseFileLock, resolveCrewxHome, type HeldFileLock } from './lock.js';
+export declare const APP_FILES_ROOT_ENV = "CREWX_APP_FILES_ROOT";
+export interface AppFilesHost {
+    readonly workspaceRoot: string;
+    readonly context?: {
+        readonly nowMs: number;
+    };
+}
+export interface AppFilesOptions {
+    readonly packageDir?: string;
+    readonly origin?: AppFilesInstallOrigin;
+    readonly source?: AppFilesSource;
+    readonly filesRoot?: string;
+    readonly env?: NodeJS.ProcessEnv;
+    readonly crewxHome?: string;
+}
+export interface AppFilesListInput {
+    readonly prefix?: string;
+    readonly after?: string;
+}
+export interface AppFiles {
+    list(input?: AppFilesListInput): Promise<AppFilesPage>;
+    read(ref: string): Promise<AppFilesRead>;
+    stat(ref: string): Promise<AppFilesListItem>;
+    write(ref: string, text: string, expectedVersion: string | null): Promise<AppFilesWritten>;
+}
+export declare function appFiles(app: AppFilesHost, options?: AppFilesOptions): AppFiles;

package/dist/app/app-files/lock.d.ts

@@ -0,0 +1,26 @@
+export declare const APP_FILES_LOCK_SUBPATH: string;
+export declare const APP_FILES_LOCK_WAIT_MS = 12000;
+interface LockOwner {
+    readonly token: string;
+    readonly pid: number;
+    readonly startedAtMs: number | null;
+}
+export interface HeldFileLock {
+    readonly path: string;
+    readonly token: string;
+}
+export declare function resolveCrewxHome(env?: NodeJS.ProcessEnv): string;
+export declare function acquireFileLock(options: {
+    readonly lockDir: string;
+    readonly key: string;
+    readonly waitMs: number;
+}): Promise<HeldFileLock>;
+export declare function releaseFileLock(held: HeldFileLock): Promise<void>;
+export declare class OwnerLiveness {
+    private readonly check;
+    private readonly now;
+    private readonly answers;
+    constructor(check?: (owner: LockOwner) => Promise<boolean>, now?: () => number);
+    isDead(owner: LockOwner): Promise<boolean>;
+}
+export {};

package/dist/app/app-files/root.d.ts

@@ -0,0 +1,22 @@
+export type AppFilesInstallOrigin = 'installed' | 'not_installed' | 'unknown';
+export type AppFilesSource = 'workspace' | 'bundled' | 'unverified';
+export type AppFilesRootWarning = 'FILES_ROOT_INVALID' | 'FILES_ROOT_FORBIDDEN';
+export interface AppFilesRootDecision {
+    readonly segments: readonly string[];
+    readonly declared: boolean;
+    readonly warning?: AppFilesRootWarning;
+}
+export declare function defaultAppFilesRootSegments(appId: string): string[];
+export declare function resolveAppFilesRoot(input: {
+    readonly appId: string;
+    readonly origin: AppFilesInstallOrigin;
+    readonly source: AppFilesSource;
+    readonly packageRelativePath?: string;
+    readonly declared: unknown;
+}): AppFilesRootDecision;
+export interface AppFilesPackageIdentity {
+    readonly appId: string | undefined;
+    readonly declared: unknown;
+}
+export declare function readAppFilesPackageIdentity(packageDir: string): Promise<AppFilesPackageIdentity>;
+export declare function appFilesRootSegmentsOf(path: string): string[] | undefined;

package/dist/app/app-files/store.d.ts

@@ -0,0 +1,48 @@
+export interface AppFilesLocation {
+    readonly workspaceReal: string;
+    readonly segments: readonly string[];
+}
+export interface AppFilesListItem {
+    readonly ref: string;
+    readonly version: string;
+    readonly bytes: number;
+    readonly modifiedAt: string;
+}
+export interface AppFilesPage {
+    readonly items: AppFilesListItem[];
+    readonly next: string | null;
+}
+export interface AppFilesRead {
+    readonly ref: string;
+    readonly text: string;
+    readonly version: string;
+}
+export interface AppFilesWritten {
+    readonly ref: string;
+    readonly version: string;
+}
+export interface AppFilesStoreHooks {
+    readonly beforeOpen?: (path: string) => Promise<void>;
+    readonly beforeMkdir?: (path: string) => Promise<void>;
+}
+export interface AppFilesStoreOptions {
+    readonly lockDir: string;
+    readonly lockWaitMs?: number;
+}
+export declare function versionOf(bytes: Uint8Array): string;
+export declare function isPathInside(root: string, candidate: string): boolean;
+export declare class AppFilesStore {
+    private readonly hooks;
+    private readonly lockDir;
+    private readonly lockWaitMs;
+    constructor(hooks: AppFilesStoreHooks | undefined, options: AppFilesStoreOptions);
+    list(location: AppFilesLocation, folder: string, after: string | undefined): Promise<AppFilesPage>;
+    read(location: AppFilesLocation, ref: string): Promise<AppFilesRead>;
+    stat(location: AppFilesLocation, ref: string): Promise<AppFilesListItem>;
+    write(location: AppFilesLocation, ref: string, text: string, expectedVersion: string | null): Promise<AppFilesWritten>;
+    private readVerified;
+    private createFolders;
+    private writeAtomically;
+    private withFileLock;
+}
+export declare function appFilesLockKeyOf(absolutePath: string): Promise<string>;

package/dist/app/app-files/write.child.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/app/app.d.ts

@@ -0,0 +1,168 @@
+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[];
+    readonly viewCall?: true;
+}
+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];