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

package/dist/route/index.d.ts

@@ -0,0 +1,14 @@
+export { RouteConfigSchema, RouteCandidateConfigSchema, RouteLinkConfigSchema } from './types.js';
+export type { JsonPrimitive, JsonValue, RouteBlockedCause, RouteCandidate, RouteCandidateConfig, RouteConfig, RouteContext, RouteDecision, RouteFunction, RouteHealth, RouteLinkConfig, RouteLinkError, RouteMode, RouteOutput, RoutePassOutput, RouteQuotaObservation, RouteRequest, RouteRunner, RouteSelectOutput, } from './types.js';
+export { RouteError, RouteRunnerError } from './errors.js';
+export type { RouteErrorCode, RouteRunnerErrorCode } from './errors.js';
+export { builtInStrategy, roundRobin, smoothWeighted } from './strategies.js';
+export { fnRunner, procRunner, resolveRouteModulePath, ROUTE_CHAIN_TIMEOUT_MS, ROUTE_JSON_MAX_BYTES, ROUTE_PROCESS_INPUT_MAX_BYTES, ROUTE_PROCESS_OUTPUT_MAX_BYTES, } from './runner.js';
+export type { ProcRunnerOptions } from './runner.js';
+export { evaluateRouteEligibility, quotaResetAt, ROUTE_QUOTA_COOLDOWN_MS } from './eligibility.js';
+export type { RouteEligibilityResult, RouteObservationSource } from './eligibility.js';
+export { MemoryRouteStore } from './store.js';
+export type { RouteCommitResult, RouteDecisionCommit, RouteDecisionStore, RouteObservationStore, RouteStateSnapshot, } from './store.js';
+export { RouteSqliteStore } from './sqlite-store.js';
+export { RouteDecisionService, previewRoute, routeConfigRevision } from './decide.js';
+export type { RecordRouteQuotaFailureInput, RouteDecisionServiceOptions, RoutePreviewItem, } from './decide.js';

package/dist/route/runner.d.ts

@@ -0,0 +1,15 @@
+import type { RouteFunction, RouteRunner } from './types.js';
+export declare const ROUTE_JSON_MAX_BYTES: number;
+export declare const ROUTE_PROCESS_INPUT_MAX_BYTES: number;
+export declare const ROUTE_PROCESS_OUTPUT_MAX_BYTES: number;
+export declare const ROUTE_CHAIN_TIMEOUT_MS = 2000;
+export interface ProcRunnerOptions {
+    workspaceRoot: string;
+    timeoutMs?: number;
+    maxInputBytes?: number;
+    maxOutputBytes?: number;
+    onSpawn?: (processGroupId: number | undefined) => void;
+}
+export declare function fnRunner(fn: RouteFunction): RouteRunner;
+export declare function procRunner(file: string, options: ProcRunnerOptions): RouteRunner;
+export declare function resolveRouteModulePath(file: string, workspaceRoot: string): string;

package/dist/route/sqlite-store.d.ts

@@ -0,0 +1,17 @@
+import { BaseSqliteRepository } from '../repository/base-sqlite-repository.js';
+import type { RouteDecision, RouteQuotaObservation, RouteCandidateConfig } from './types.js';
+import type { RouteDecisionCommit, RouteDecisionStore, RouteObservationStore, RouteStateSnapshot, RouteCommitResult } from './store.js';
+export declare class RouteSqliteStore extends BaseSqliteRepository implements RouteDecisionStore, RouteObservationStore {
+    private readonly configuredDbPath?;
+    constructor(options?: {
+        dbPath?: string;
+        dbRoot?: string;
+    });
+    resolveDbPath(): string;
+    private openHandle;
+    getDecision(routeId: string, taskId: string): Promise<RouteDecision | undefined>;
+    loadState(routeId: string, threadId: string | null, configRevision: string): Promise<RouteStateSnapshot>;
+    commitDecision(input: RouteDecisionCommit): Promise<RouteCommitResult>;
+    recordQuotaObservation(observation: RouteQuotaObservation, observedAt: number): Promise<void>;
+    getObservations(candidates: readonly RouteCandidateConfig[], _now: number): Promise<RouteQuotaObservation[]>;
+}

package/dist/route/store.d.ts

@@ -0,0 +1,45 @@
+import type { JsonValue, RouteDecision, RouteQuotaObservation, RouteCandidateConfig } from './types.js';
+export interface RouteStateSnapshot {
+    revision: number;
+    storedConfigRevision: string | null;
+    states: Record<string, JsonValue>;
+    stickyCandidateId?: string;
+}
+export interface RouteDecisionCommit {
+    decision: RouteDecision;
+    expectedRevision: number;
+    expectedStoredConfigRevision: string | null;
+    configRevision: string;
+    states: Record<string, JsonValue>;
+    threadId: string | null;
+    stickyCandidateId?: string;
+}
+export type RouteCommitResult = {
+    status: 'saved';
+    decision: RouteDecision;
+} | {
+    status: 'conflict';
+} | {
+    status: 'existing';
+    decision: RouteDecision;
+};
+export interface RouteDecisionStore {
+    getDecision(routeId: string, taskId: string): Promise<RouteDecision | undefined>;
+    loadState(routeId: string, threadId: string | null, configRevision: string): Promise<RouteStateSnapshot>;
+    commitDecision(input: RouteDecisionCommit): Promise<RouteCommitResult>;
+    recordQuotaObservation(observation: RouteQuotaObservation, observedAt: number): Promise<void>;
+}
+export interface RouteObservationStore {
+    getObservations(candidates: readonly RouteCandidateConfig[], now: number): Promise<RouteQuotaObservation[]>;
+}
+export declare class MemoryRouteStore implements RouteDecisionStore, RouteObservationStore {
+    private readonly states;
+    private readonly sticky;
+    private readonly decisions;
+    private readonly observations;
+    getDecision(routeId: string, taskId: string): Promise<RouteDecision | undefined>;
+    loadState(routeId: string, threadId: string | null, configRevision: string): Promise<RouteStateSnapshot>;
+    commitDecision(input: RouteDecisionCommit): Promise<RouteCommitResult>;
+    recordQuotaObservation(observation: RouteQuotaObservation, observedAt: number): Promise<void>;
+    getObservations(candidates: readonly RouteCandidateConfig[], _now: number): Promise<RouteQuotaObservation[]>;
+}

package/dist/route/strategies.d.ts

@@ -0,0 +1,4 @@
+import type { RouteContext, RouteOutput } from './types.js';
+export declare function roundRobin(ctx: Readonly<RouteContext>): RouteOutput;
+export declare function smoothWeighted(ctx: Readonly<RouteContext>): RouteOutput;
+export declare function builtInStrategy(strategy: 'round-robin' | 'weighted'): typeof roundRobin;

package/dist/route/types.d.ts

@@ -0,0 +1,212 @@
+import { z } from 'zod';
+export declare const RouteCandidateConfigSchema: z.ZodObject<{
+    id: z.ZodString;
+    provider: z.ZodString;
+    model: z.ZodString;
+    weight: z.ZodDefault<z.ZodNumber>;
+    account: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    id: string;
+    model: string;
+    provider: string;
+    weight: number;
+    account?: string | undefined;
+}, {
+    id: string;
+    model: string;
+    provider: string;
+    weight?: number | undefined;
+    account?: string | undefined;
+}>;
+export declare const RouteLinkConfigSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"custom">;
+    run: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    kind: "custom";
+    run: string;
+}, {
+    kind: "custom";
+    run: string;
+}>;
+export declare const RouteConfigSchema: z.ZodEffects<z.ZodObject<{
+    strategy: z.ZodEnum<["round-robin", "weighted"]>;
+    chain: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        kind: z.ZodLiteral<"custom">;
+        run: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        kind: "custom";
+        run: string;
+    }, {
+        kind: "custom";
+        run: string;
+    }>, "many">>;
+    candidates: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        provider: z.ZodString;
+        model: z.ZodString;
+        weight: z.ZodDefault<z.ZodNumber>;
+        account: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        id: string;
+        model: string;
+        provider: string;
+        weight: number;
+        account?: string | undefined;
+    }, {
+        id: string;
+        model: string;
+        provider: string;
+        weight?: number | undefined;
+        account?: string | undefined;
+    }>, "many">;
+    sticky: z.ZodDefault<z.ZodEnum<["conversation", "none"]>>;
+    defaultCandidate: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    strategy: "round-robin" | "weighted";
+    candidates: {
+        id: string;
+        model: string;
+        provider: string;
+        weight: number;
+        account?: string | undefined;
+    }[];
+    sticky: "none" | "conversation";
+    chain?: {
+        kind: "custom";
+        run: string;
+    }[] | undefined;
+    defaultCandidate?: string | undefined;
+}, {
+    strategy: "round-robin" | "weighted";
+    candidates: {
+        id: string;
+        model: string;
+        provider: string;
+        weight?: number | undefined;
+        account?: string | undefined;
+    }[];
+    chain?: {
+        kind: "custom";
+        run: string;
+    }[] | undefined;
+    sticky?: "none" | "conversation" | undefined;
+    defaultCandidate?: string | undefined;
+}>, {
+    strategy: "round-robin" | "weighted";
+    candidates: {
+        id: string;
+        model: string;
+        provider: string;
+        weight: number;
+        account?: string | undefined;
+    }[];
+    sticky: "none" | "conversation";
+    chain?: {
+        kind: "custom";
+        run: string;
+    }[] | undefined;
+    defaultCandidate?: string | undefined;
+}, {
+    strategy: "round-robin" | "weighted";
+    candidates: {
+        id: string;
+        model: string;
+        provider: string;
+        weight?: number | undefined;
+        account?: string | undefined;
+    }[];
+    chain?: {
+        kind: "custom";
+        run: string;
+    }[] | undefined;
+    sticky?: "none" | "conversation" | undefined;
+    defaultCandidate?: string | undefined;
+}>;
+export type RouteCandidateConfig = z.infer<typeof RouteCandidateConfigSchema>;
+export type RouteLinkConfig = z.infer<typeof RouteLinkConfigSchema>;
+export type RouteConfig = z.infer<typeof RouteConfigSchema>;
+export type JsonPrimitive = string | number | boolean | null;
+export type JsonValue = JsonPrimitive | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+export type RouteHealth = 'ok' | 'unknown' | 'blocked';
+export type RouteMode = 'query' | 'execute';
+export interface RouteCandidate {
+    id: string;
+    provider: string;
+    model: string;
+    weight: number;
+    eligible: boolean;
+    health: RouteHealth;
+    resetAt?: number;
+}
+export interface RouteContext {
+    v: 1;
+    route: {
+        id: string;
+        revision: string;
+    };
+    request: {
+        taskId: string;
+        threadId: string | null;
+        agentId: string;
+        mode: RouteMode;
+    };
+    now: number;
+    candidates: RouteCandidate[];
+    state: JsonValue;
+}
+export interface RouteSelectOutput {
+    type: 'select';
+    candidateId: string;
+    nextState: JsonValue;
+    reason: string;
+}
+export interface RoutePassOutput {
+    type: 'pass';
+}
+export type RouteOutput = RouteSelectOutput | RoutePassOutput;
+export type RouteFunction = (ctx: Readonly<RouteContext>) => RouteOutput | unknown | Promise<RouteOutput | unknown>;
+export type RouteRunner = (ctx: RouteContext, timeoutMs?: number) => Promise<unknown>;
+export interface RouteBlockedCause {
+    candidateId: string;
+    provider: string;
+    accountRef: string;
+    model?: string;
+    source: string;
+    scope: 'account' | 'account-model';
+    resetAt: number;
+}
+export interface RouteLinkError {
+    link: string;
+    code: string;
+    message: string;
+}
+export interface RouteDecision {
+    routeId: string;
+    taskId: string;
+    configRevision: string;
+    candidateId: string;
+    provider: string;
+    model: string;
+    reason: string;
+    eligibleIds: string[];
+    blockedCauses: RouteBlockedCause[];
+    linkErrors: RouteLinkError[];
+    createdAt: number;
+}
+export interface RouteQuotaObservation {
+    provider: string;
+    accountRef: string;
+    model?: string;
+    status: 'ok' | 'blocked';
+    source: string;
+    resetAt?: number;
+}
+export interface RouteRequest {
+    taskId: string;
+    threadId: string | null;
+    agentId: string;
+    mode: RouteMode;
+    namedAcpSession?: boolean;
+}

package/dist/schema/agent-send-history.d.ts

@@ -0,0 +1,85 @@
+export declare const agent_send_history: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "agent_send_history";
+    schema: undefined;
+    columns: {
+        workspace_id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "workspace_id";
+            tableName: "agent_send_history";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        actor_id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "actor_id";
+            tableName: "agent_send_history";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        agent_id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "agent_id";
+            tableName: "agent_send_history";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        last_accepted_at: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "last_accepted_at";
+            tableName: "agent_send_history";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+    };
+    dialect: "sqlite";
+}>;
+export type AgentSendHistory = typeof agent_send_history.$inferSelect;
+export type NewAgentSendHistory = typeof agent_send_history.$inferInsert;

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

@@ -0,0 +1,199 @@
+export declare const agent_suggestions: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "agent_suggestions";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "id";
+            tableName: "agent_suggestions";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        workspace_id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "workspace_id";
+            tableName: "agent_suggestions";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        agent_id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "agent_id";
+            tableName: "agent_suggestions";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        task_id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "task_id";
+            tableName: "agent_suggestions";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        type: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "type";
+            tableName: "agent_suggestions";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        status: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "status";
+            tableName: "agent_suggestions";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        payload: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "payload";
+            tableName: "agent_suggestions";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        applied_commit_sha: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "applied_commit_sha";
+            tableName: "agent_suggestions";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        created_at: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "created_at";
+            tableName: "agent_suggestions";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        updated_at: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "updated_at";
+            tableName: "agent_suggestions";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+    };
+    dialect: "sqlite";
+}>;
+export type AgentSuggestion = typeof agent_suggestions.$inferSelect;
+export type NewAgentSuggestion = typeof agent_suggestions.$inferInsert;