@zhivex-ai/harness 0.6.1 → 0.7.0

package/dist/providers.d.ts

@@ -0,0 +1,77 @@
+import type { LanguageModel } from "@zhivex-ai/agents";
+export declare const PROVIDERS: readonly ["meta", "qwen", "openai", "gemini"];
+export type BuiltInHarnessProvider = (typeof PROVIDERS)[number];
+export type HarnessProvider = BuiltInHarnessProvider | (string & {});
+export type ProviderCapability = "streaming" | "tool-calling" | "approval-resume";
+export type ProviderSupport = "certified" | "provisional";
+export interface ProviderDescriptor {
+    readonly id: HarnessProvider;
+    readonly name: string;
+    readonly defaultModel: string;
+    readonly credentialNames: readonly string[];
+    readonly capabilities: readonly ProviderCapability[];
+    readonly support: ProviderSupport;
+}
+export interface ProviderCredentials {
+    readonly names: readonly string[];
+    get(name: string): string | undefined;
+    first(): string | undefined;
+    require(): string;
+}
+export interface ProviderModelFactoryContext {
+    readonly provider: HarnessProvider;
+    readonly model: string;
+    readonly env: NodeJS.ProcessEnv;
+    readonly credentials: ProviderCredentials;
+}
+export type ProviderModelFactory = (context: ProviderModelFactoryContext) => LanguageModel;
+export interface ProviderPresenceDiagnostic {
+    /** Output is exposed as `<key>Configured`; the environment value is never returned. */
+    readonly key: string;
+    readonly environmentVariable: string;
+}
+export interface ProviderEnumDiagnostic extends ProviderPresenceDiagnostic {
+    /** Output also includes `<key>Valid`, based only on membership in this allowlist. */
+    readonly allowedValues: readonly string[];
+}
+export interface ProviderDiagnosticsDescriptor {
+    /** Produces only customEndpoint, endpointValid, and endpointSecure booleans. */
+    readonly endpointEnvironmentVariable?: string;
+    readonly presence?: readonly ProviderPresenceDiagnostic[];
+    readonly enums?: readonly ProviderEnumDiagnostic[];
+}
+export interface ProviderRegistration {
+    readonly descriptor: ProviderDescriptor;
+    readonly factory: ProviderModelFactory;
+    readonly diagnostics?: ProviderDiagnosticsDescriptor;
+}
+export interface ProviderAvailability extends ProviderDescriptor {
+    readonly configured: boolean;
+    readonly credentials: readonly {
+        readonly name: string;
+        readonly present: boolean;
+    }[];
+    readonly configuration: Readonly<Record<string, boolean>> & {
+        readonly customEndpoint: boolean;
+        readonly endpointValid: boolean;
+        readonly endpointSecure: boolean;
+    };
+}
+export interface HarnessProviderRegistry {
+    readonly descriptors: readonly ProviderDescriptor[];
+    has(provider: string): boolean;
+    parse(value?: string): HarnessProvider;
+    descriptor(provider: HarnessProvider): ProviderDescriptor;
+    createModel(config: Readonly<{
+        provider: HarnessProvider;
+        model: string;
+    }>, env?: NodeJS.ProcessEnv): LanguageModel;
+    availability(env?: NodeJS.ProcessEnv): readonly ProviderAvailability[];
+    /** Stable hash of non-credential transport settings used by durable resume bindings. */
+    transportFingerprint(env?: NodeJS.ProcessEnv): string;
+    extend(registrations: readonly ProviderRegistration[]): HarnessProviderRegistry;
+}
+export declare const createProviderRegistry: (registrations: readonly ProviderRegistration[]) => HarnessProviderRegistry;
+export declare const BUILTIN_PROVIDER_REGISTRATIONS: readonly ProviderRegistration[];
+export declare const DEFAULT_PROVIDER_REGISTRY: HarnessProviderRegistry;
+export declare const PROVIDER_DESCRIPTORS: readonly ProviderDescriptor[];

package/dist/routing.d.ts

@@ -0,0 +1,16 @@
+import type { LanguageModel } from "@zhivex-ai/agents";
+import { type HarnessProviderRegistry, type HarnessSubagentProfile } from "./config.js";
+export interface HarnessModelRoute {
+    profile: HarnessSubagentProfile;
+    provider: string;
+    model: string;
+}
+export declare const parseHarnessModelRoute: (value: string, registry?: HarnessProviderRegistry) => HarnessModelRoute;
+export declare const resolveHarnessModelRoutes: (values?: readonly string[], registry?: HarnessProviderRegistry) => Map<"explorer" | "implementer" | "tester" | "reviewer", HarnessModelRoute>;
+export declare const createHarnessRouteModels: (routes: ReadonlyMap<HarnessSubagentProfile, HarnessModelRoute>, env?: NodeJS.ProcessEnv, registry?: HarnessProviderRegistry) => Partial<Record<HarnessSubagentProfile, LanguageModel>>;
+export declare const serializeHarnessModelRoutes: (routes: ReadonlyMap<HarnessSubagentProfile, HarnessModelRoute>) => {
+    [k: string]: {
+        provider: string;
+        model: string;
+    };
+};

package/dist/sessions.d.ts

@@ -0,0 +1,122 @@
+import type { AgentStoreScope } from "@zhivex-ai/agents/ops";
+export declare const HARNESS_SESSION_INDEX_FILE = "operations.sqlite";
+export declare const HARNESS_SESSION_SCHEMA_VERSION: 1;
+export declare const SESSION_RUN_STATUSES: readonly ["created", "running", "waiting_approval", "cancel_requested", "completed", "failed", "cancelled", "timed_out"];
+export declare const TERMINAL_SESSION_RUN_STATUSES: readonly ["completed", "failed", "cancelled", "timed_out"];
+export type SessionRunStatus = (typeof SESSION_RUN_STATUSES)[number];
+export interface SessionRunReference {
+    turnId: string;
+    sourceTurnId?: string;
+    sequence: number;
+    runId: string;
+    provider: string;
+    model: string;
+    role?: string;
+    status: SessionRunStatus;
+    createdAt: number;
+    updatedAt: number;
+    completedAt?: number;
+}
+export interface CliSession {
+    schemaVersion: typeof HARNESS_SESSION_SCHEMA_VERSION;
+    sessionId: string;
+    workspaceKey: string;
+    scopeKey: string;
+    title?: string;
+    parentSessionId?: string;
+    forkedFromTurnId?: string;
+    revision: number;
+    createdAt: number;
+    updatedAt: number;
+    archivedAt?: number;
+    deletedAt?: number;
+    runs: SessionRunReference[];
+}
+export interface CliSessionSummary extends Omit<CliSession, "runs"> {
+    runCount: number;
+    latestRun?: SessionRunReference;
+}
+export interface CreateSessionInput {
+    /** A short operator-facing label. It is redacted before persistence and must not contain a prompt. */
+    title?: string;
+    initialRun?: AppendSessionRunInput;
+}
+export interface AppendSessionRunInput {
+    runId: string;
+    provider: string;
+    model: string;
+    role?: string;
+    status?: SessionRunStatus;
+    createdAt?: number;
+}
+export interface UpdateSessionRunInput {
+    status: SessionRunStatus;
+    updatedAt?: number;
+    completedAt?: number;
+    expectedSessionRevision?: number;
+}
+export interface UpdateSessionInput {
+    title?: string | null;
+    archived?: boolean;
+    expectedRevision?: number;
+}
+export interface ListSessionsQuery {
+    limit?: number;
+    includeArchived?: boolean;
+    includeDeleted?: boolean;
+}
+export interface ForkSessionInput {
+    atTurnId?: string;
+    title?: string;
+    expectedRevision?: number;
+}
+export interface SessionRetentionResult {
+    before: number;
+    deletedSessions: number;
+}
+export interface OpenSessionStoreOptions {
+    workspace: string;
+    stateDirectory: string;
+    scope: AgentStoreScope;
+    retentionMs?: number;
+    maxSessionsPerWorkspace?: number;
+    maxRunsPerSession?: number;
+    maxMetadataBytes?: number;
+    maxIndexBytes?: number;
+    now?: () => number;
+}
+export interface CliSessionStore {
+    readonly databasePath: string;
+    readonly workspaceKey: string;
+    readonly scopeKey: string;
+    create(input?: CreateSessionInput): Promise<CliSession>;
+    get(sessionId: string, options?: {
+        includeDeleted?: boolean;
+    }): Promise<CliSession | undefined>;
+    list(query?: ListSessionsQuery): Promise<CliSessionSummary[]>;
+    latest(options?: {
+        includeArchived?: boolean;
+    }): Promise<CliSession | undefined>;
+    update(sessionId: string, input: UpdateSessionInput): Promise<CliSession>;
+    rename(sessionId: string, title: string, options?: {
+        expectedRevision?: number;
+    }): Promise<CliSession>;
+    appendRun(sessionId: string, input: AppendSessionRunInput, options?: {
+        expectedRevision?: number;
+    }): Promise<CliSession>;
+    updateRun(sessionId: string, runId: string, input: UpdateSessionRunInput): Promise<CliSession>;
+    fork(sessionId: string, input?: ForkSessionInput): Promise<CliSession>;
+    archive(sessionId: string, options?: {
+        expectedRevision?: number;
+    }): Promise<CliSession>;
+    delete(sessionId: string, options?: {
+        expectedRevision?: number;
+    }): Promise<CliSession>;
+    prune(options?: {
+        before?: number;
+    }): Promise<SessionRetentionResult>;
+    close(): void;
+}
+export declare const openCliSessionStore: (options: OpenSessionStoreOptions) => Promise<CliSessionStore>;
+/** Compatibility-friendly name for consumers that do not care that the index is CLI-owned. */
+export declare const openSessionStore: (options: OpenSessionStoreOptions) => Promise<CliSessionStore>;