@fenixforce/kernel 0.1.0

package/dist/providers/optimization-modes.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Optimization Modes — route requests to providers based on
+ * speed, cost, or quality preference.
+ *
+ * Configurable per workspace and overridable per conversation.
+ * Ties into model registry capabilities and pricing data.
+ */
+import type { ModelEntry, ModelRegistry } from "./model-registry.js";
+export type OptimizationMode = "speed" | "cost" | "quality";
+export interface OptimizationConfig {
+    /** Default mode for the workspace. */
+    defaultMode: OptimizationMode;
+    /** Per-conversation override (takes priority). */
+    conversationOverride?: OptimizationMode;
+}
+export interface RankedModel {
+    entry: ModelEntry;
+    score: number;
+}
+/**
+ * Resolve the active optimization mode from config.
+ * Conversation override takes priority over workspace default.
+ */
+export declare function resolveMode(config: OptimizationConfig): OptimizationMode;
+/**
+ * Rank models from the registry by the active optimization mode.
+ * Returns models sorted from best to worst for the given mode.
+ */
+export declare function rankModels(registry: ModelRegistry, mode: OptimizationMode, provider?: string): RankedModel[];
+/**
+ * Pick the best model for a given optimization mode.
+ * Optionally filter by provider. Returns null if no models available.
+ */
+export declare function pickBestModel(registry: ModelRegistry, mode: OptimizationMode, provider?: string): ModelEntry | null;
+/**
+ * Create an OptimizationConfig with defaults.
+ */
+export declare function createOptimizationConfig(defaultMode?: OptimizationMode, conversationOverride?: OptimizationMode): OptimizationConfig;

package/dist/providers/provider-manager.d.ts

@@ -0,0 +1,71 @@
+import type { ResolvedProviderConfig, ResolvedSlot } from "../config/provider-config.js";
+import type { ProviderCapabilities } from "./interface.js";
+import { ProviderCircuitBreaker } from "./circuit-breaker.js";
+import { CostTrackingProvider } from "./cost-tracking.js";
+export interface LLMProvider {
+    readonly id: string;
+    complete(params: unknown): Promise<unknown>;
+    capabilities?(): ProviderCapabilities;
+}
+export type ProviderFactory = (slot: ResolvedSlot) => LLMProvider;
+export type TaskType = "conversation" | "code_generation" | "memory_extraction" | "classification" | "embedding";
+export interface ProviderManagerConfig {
+    /** Named provider slots, e.g. { chat: provider1, fast: provider2 } */
+    slots: Record<string, LLMProvider>;
+    /** Maps task type → preferred slot name, overrides DEFAULT_TASK_SLOTS */
+    routingPreferences?: Partial<Record<string, string>>;
+    /** Enable circuit breakers per slot (default: false) */
+    enableCircuitBreakers?: boolean;
+    /** Enable cost tracking wrappers (default: false) */
+    enableCostTracking?: boolean;
+}
+export declare class ProviderManager {
+    private slots;
+    private routingPreferences;
+    private breakers;
+    private costTrackers;
+    constructor(config: ProviderManagerConfig);
+    /** Register or replace a named provider slot */
+    setSlot(name: string, provider: LLMProvider): void;
+    /** Get a provider by slot name, or undefined */
+    getSlot(name: string): LLMProvider | undefined;
+    /** Set a routing preference: taskType → slotName */
+    setPreference(taskType: string, slotName: string): void;
+    /**
+     * Get the preferred provider for a task type.
+     *
+     * Resolution order:
+     * 1. "embedding" always routes to the "embed" slot (hard rule)
+     * 2. routingPreferences[taskType] → use that slot if it exists
+     * 3. DEFAULT_TASK_SLOTS[taskType] → use the default slot for this type
+     * 4. Fall back to "chat" slot
+     *
+     * At each step, if the resolved slot doesn't exist, continue to next.
+     * Throws if no provider can be resolved at all.
+     */
+    getPreferred(taskType: string): LLMProvider;
+    /**
+     * Get a healthy provider for a slot (circuit breaker aware).
+     * Returns the slot's provider if its circuit breaker is closed or half-open.
+     * Returns undefined if the breaker is open.
+     */
+    getHealthy(slotName: string): LLMProvider | undefined;
+    /** Get the circuit breaker for a slot (if enabled) */
+    getBreaker(slotName: string): ProviderCircuitBreaker | undefined;
+    /** Get the cost tracker for a slot (if enabled) */
+    getCostTracker(slotName: string): CostTrackingProvider | undefined;
+    /**
+     * Find a slot whose provider has a specific capability.
+     * Returns the first matching slot name, or undefined.
+     */
+    findByCapability(capability: keyof ProviderCapabilities): LLMProvider | undefined;
+    /** List all registered slot names */
+    listSlots(): string[];
+    /**
+     * Build a ProviderManager from a normalized config.
+     * Shares provider instances when multiple slots reference the same
+     * provider+apiKeys combination (v1.5 multi-modality).
+     */
+    static fromConfig(resolved: ResolvedProviderConfig, factory: ProviderFactory, routingPreferences?: Partial<Record<string, string>>): ProviderManager;
+    private isFullProvider;
+}

package/dist/providers/runtime-crud.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Runtime Provider CRUD — API endpoints for managing providers at runtime.
+ *
+ * POST   /api/v1/providers          — add a new provider configuration
+ * PUT    /api/v1/providers/:id      — update provider config
+ * DELETE /api/v1/providers/:id      — remove provider
+ * POST   /api/v1/providers/:id/test — test connectivity
+ *
+ * Validates credentials, runs health check, persists to encrypted
+ * credentials store. ~80 lines of logic.
+ */
+import type { ProviderSlot, LLMProvider } from "./interface.js";
+import type { SecretStore } from "../security/secret-store.js";
+export interface ProviderEntry {
+    id: string;
+    provider: string;
+    slot: ProviderSlot;
+    model?: string;
+    baseUrl?: string;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface CreateProviderInput {
+    /** Provider type (e.g. "anthropic", "openai", "google"). */
+    provider: string;
+    /** Slot to assign this provider to. */
+    slot: ProviderSlot;
+    /** API key. */
+    apiKey: string;
+    /** Optional model override. */
+    model?: string;
+    /** Optional base URL override. */
+    baseUrl?: string;
+}
+export interface UpdateProviderInput {
+    slot?: ProviderSlot;
+    apiKey?: string;
+    model?: string;
+    baseUrl?: string;
+}
+export interface TestResult {
+    ok: boolean;
+    latencyMs: number;
+    error?: string;
+    model?: string;
+}
+export type ProviderFactory = (type: string, config: {
+    apiKey: string;
+    model?: string;
+    baseUrl?: string;
+}) => LLMProvider;
+export interface RuntimeProviderCRUDConfig {
+    secretStore: SecretStore;
+    /** Factory to instantiate an LLMProvider from type + config. */
+    createProvider: ProviderFactory;
+    /** User ID that owns these providers (for secret store scoping). */
+    userId: string;
+}
+export declare function _resetProviderIds(): void;
+export interface RuntimeProviderCRUD {
+    create(input: CreateProviderInput): Promise<ProviderEntry>;
+    update(id: string, input: UpdateProviderInput): Promise<ProviderEntry | undefined>;
+    remove(id: string): Promise<boolean>;
+    test(id: string): Promise<TestResult>;
+    get(id: string): ProviderEntry | undefined;
+    list(): ProviderEntry[];
+}
+export declare function createRuntimeProviderCRUD(config: RuntimeProviderCRUDConfig): RuntimeProviderCRUD;

package/dist/providers/sidecar-lifecycle.d.ts

@@ -0,0 +1,40 @@
+type Listener = (...args: any[]) => void;
+declare class TypedEmitter {
+    private _listeners;
+    on(event: string, fn: Listener): this;
+    off(event: string, fn: Listener): this;
+    emit(event: string, ...args: unknown[]): boolean;
+}
+export interface SidecarConfig {
+    command: string;
+    healthEndpoint: string;
+    maxRestartAttempts: number;
+    failureCooldownMs: number;
+    backoffMultiplier: number;
+    maxCooldownMs: number;
+    fallbackProvider?: string;
+}
+export type SidecarState = "running" | "starting" | "restarting" | "cooldown" | "probing" | "stopped";
+export type StartFn = (command: string) => Promise<boolean>;
+export type HealthCheckFn = (endpoint: string) => Promise<boolean>;
+export declare class SidecarLifecycle extends TypedEmitter {
+    readonly config: SidecarConfig;
+    private _state;
+    private restartAttempts;
+    private cooldownCycle;
+    private cooldownTimer;
+    private startFn;
+    private healthCheckFn;
+    constructor(config: Partial<SidecarConfig> & Pick<SidecarConfig, "command">, startFn: StartFn, healthCheckFn: HealthCheckFn);
+    get state(): SidecarState;
+    get currentCooldownCycle(): number;
+    get currentRestartAttempts(): number;
+    get activeFallback(): string | null;
+    private setState;
+    start(): Promise<boolean>;
+    handleFailure(): Promise<void>;
+    private enterCooldown;
+    probe(): Promise<boolean>;
+    stop(): void;
+}
+export {};

package/dist/providers/stream-wrapper.d.ts

@@ -0,0 +1,21 @@
+export interface ChatCompletionChunk {
+    id?: string;
+    choices: Array<{
+        delta: {
+            content?: string;
+            role?: string;
+        };
+        finish_reason: string | null;
+        index: number;
+    }>;
+    usage?: {
+        prompt_tokens?: number;
+        completion_tokens?: number;
+        total_tokens?: number;
+    };
+}
+export interface TokenUsage {
+    input: number;
+    output: number;
+}
+export declare function createOpenAICompatibleStream(response: AsyncIterable<ChatCompletionChunk>, onTokens?: (usage: TokenUsage) => void): ReadableStream<Uint8Array>;

package/dist/providers/structured-verify.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Structured Output Verification — wraps generateObject with schema
+ * validation and retry logic.
+ *
+ * Calls the provider's generateObject, validates the result against
+ * a JSON schema, and retries up to 2x on validation failure.
+ * Logs schema violations for debugging.
+ */
+import type { LLMProvider, GenerateObjectParams } from "./interface.js";
+export interface VerifyOptions {
+    /** Max retry attempts after validation failure (default: 2) */
+    maxRetries?: number;
+    /** Custom validation function — return null if valid, or error string */
+    validate?: (result: unknown) => string | null;
+}
+export interface VerifyResult<T> {
+    data: T;
+    attempts: number;
+    violations: string[];
+}
+/**
+ * Generate a structured object with validation and retry.
+ *
+ * @throws Error if provider doesn't support generateObject
+ * @throws Error if validation fails after all retries
+ */
+export declare function verifiedGenerateObject<T = unknown>(provider: LLMProvider, params: GenerateObjectParams, options?: VerifyOptions): Promise<VerifyResult<T>>;
+export declare class StructuredOutputError extends Error {
+    readonly violations: string[];
+    constructor(message: string, violations: string[]);
+}

package/dist/providers/versioning.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Provider Versioning — independent semver for voice sidecar binaries.
+ * Kernel checks compatibility range on startup to prevent broken updates
+ * when sidecar and kernel version independently.
+ */
+export interface VersionCompat {
+    sidecar: string;
+    kernelMin: string;
+    kernelMax: string;
+}
+export interface VersionCheckResult {
+    compatible: boolean;
+    sidecar: string;
+    kernel: string;
+    range: string;
+}
+/** Check if the current kernel version falls within a sidecar's compat range. */
+export declare function checkCompatibility(kernelVersion: string, compat: VersionCompat): VersionCheckResult;

package/dist/quality-gates.d.ts

@@ -0,0 +1,10 @@
+import type { AgentEvent, TaskTracker } from "./events/types.js";
+export type ConditionFn = () => boolean | Promise<boolean>;
+export interface QualityGateInput {
+    sessionId: string;
+    tracker: TaskTracker;
+    /** Map of taskId → condition function */
+    conditions: Record<string, ConditionFn>;
+    maxRetries?: number;
+}
+export declare function qualityGates(input: QualityGateInput): AsyncGenerator<AgentEvent>;

package/dist/scheduler/engine.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Scheduler Engine — extends the planned-tasks scheduler with
+ * cron expressions, one-shot datetime scheduling, and recurring
+ * patterns. Manages progression by enqueuing steps into the job
+ * queue when their scheduled time arrives.
+ *
+ * Schedule types:
+ *  - cron:      Standard 5-field cron expression (min hour dom mon dow)
+ *  - once:      Single datetime execution
+ *  - recurring: Interval-based repetition (every N ms)
+ */
+import { type PlannedTaskScheduler, type SchedulerJobQueue, type SchedulerEventListener } from "../jobs/planned-tasks.js";
+export interface CronField {
+    type: "wildcard" | "value" | "range" | "list" | "step";
+    values: number[];
+}
+/**
+ * Parse a standard 5-field cron expression into structured fields.
+ * Fields: minute (0-59), hour (0-23), day-of-month (1-31), month (1-12), day-of-week (0-6).
+ *
+ * Supports: *, N, N-M, N,M,O, *\/N (step)
+ */
+export declare function parseCronExpression(expr: string): CronField[];
+/**
+ * Get the next execution time after `after` that matches the cron expression.
+ */
+export declare function nextCronTime(fields: CronField[], after?: Date): Date;
+export type ScheduleType = "cron" | "once" | "recurring";
+export interface CronSchedule {
+    type: "cron";
+    /** Standard 5-field cron expression. */
+    expression: string;
+    /** Maximum number of executions (default: unlimited). */
+    maxExecutions?: number;
+}
+export interface OnceSchedule {
+    type: "once";
+    /** When to execute. */
+    runAt: Date;
+}
+export interface RecurringSchedule {
+    type: "recurring";
+    /** Interval in ms between executions. */
+    intervalMs: number;
+    /** When to start. Defaults to now. */
+    startAt?: Date;
+    /** Maximum number of executions (default: unlimited). */
+    maxExecutions?: number;
+}
+export type Schedule = CronSchedule | OnceSchedule | RecurringSchedule;
+export interface ScheduledEntry {
+    id: string;
+    name: string;
+    schedule: Schedule;
+    jobType: string;
+    payload: Record<string, unknown>;
+    chatId?: string;
+    executionCount: number;
+    active: boolean;
+    nextRunAt: Date | null;
+    createdAt: Date;
+}
+export interface SchedulerEngineConfig {
+    /** Job queue to enqueue scheduled work into. */
+    queue: SchedulerJobQueue;
+    /** Override Date.now() for testing. */
+    nowFn?: () => number;
+}
+export declare function _resetEngineIds(): void;
+export interface SchedulerEngine {
+    /** Schedule a new entry. Returns the entry. */
+    schedule(opts: {
+        name: string;
+        schedule: Schedule;
+        jobType: string;
+        payload?: Record<string, unknown>;
+        chatId?: string;
+    }): ScheduledEntry;
+    /** Cancel a scheduled entry. */
+    cancel(entryId: string): boolean;
+    /** Get an entry by ID. */
+    get(entryId: string): ScheduledEntry | undefined;
+    /** List all entries. */
+    list(): ScheduledEntry[];
+    /** Access the underlying planned-task scheduler. */
+    readonly taskScheduler: PlannedTaskScheduler;
+    /** Events passthrough to planned-task scheduler. */
+    on(listener: SchedulerEventListener): void;
+    off(listener: SchedulerEventListener): void;
+    /** Clean up all timers. */
+    dispose(): void;
+}
+export declare function createSchedulerEngine(config: SchedulerEngineConfig): SchedulerEngine;
+export type { PlannedTask, PlannedStep, PlannedStepInput, PlannedStepStatus, PlannedTaskStatus, PlannedTaskScheduler, SchedulerJobQueue, SchedulerEventType, SchedulerEvent, SchedulerEventListener, CreatePlannedTaskInput, } from "../jobs/planned-tasks.js";
+export { createPlannedTaskScheduler, _resetTaskIds } from "../jobs/planned-tasks.js";

package/dist/scheduler/index.d.ts

@@ -0,0 +1,4 @@
+export { createScheduledWebhookJob, isWebhookJob, createWebhookHandler, verifyGitHubSignature, verifyStripeSignature, verifyGenericAuth, safeEqual, extractWebhookContent, createWebhookEnvelope, } from "./webhook-handler.js";
+export type { ScheduledWebhookJob, WebhookProvider, GitHubWebhookConfig, StripeWebhookConfig, GenericWebhookConfig, WebhookConfig, WebhookRegistration, WebhookRequest, WebhookResult, WebhookEventType, WebhookEvent, WebhookEventListener, WebhookJobQueue, WebhookHandlerConfig, WebhookHandler, WebhookMessageEnvelope, } from "./webhook-handler.js";
+export { createSchedulerEngine, parseCronExpression, nextCronTime, createPlannedTaskScheduler, _resetTaskIds, _resetEngineIds, } from "./engine.js";
+export type { CronField, ScheduleType, CronSchedule, OnceSchedule, RecurringSchedule, Schedule, ScheduledEntry, SchedulerEngineConfig, SchedulerEngine, PlannedTask, PlannedStep, PlannedStepInput, PlannedStepStatus, PlannedTaskStatus, PlannedTaskScheduler, SchedulerJobQueue, SchedulerEventType, SchedulerEvent, SchedulerEventListener, CreatePlannedTaskInput, } from "./engine.js";

package/dist/scheduler/webhook-handler.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Webhook Handler — creates `type: "webhook"` scheduled jobs from
+ * incoming POST /api/v1/webhooks/:id requests.
+ *
+ * This module re-exports the core webhook trigger machinery and adds
+ * the ScheduledWebhookJob type that integrates webhooks into the
+ * job queue + planned-tasks scheduler pipeline.
+ *
+ * Supported providers:
+ *  - GitHub:  SHA-256 HMAC via x-hub-signature-256
+ *  - Stripe:  Custom t=...,v1=... signature via stripe-signature
+ *  - Generic: Bearer token, custom header, or IP allowlist
+ *
+ * All signature comparisons use crypto.timingSafeEqual.
+ */
+import type { WebhookMessageEnvelope, WebhookProvider } from "../api/webhook-triggers.js";
+export interface ScheduledWebhookJob {
+    type: "webhook";
+    webhookId: string;
+    provider: WebhookProvider;
+    envelope: WebhookMessageEnvelope;
+    /** ISO timestamp of when the webhook was received. */
+    receivedAt: string;
+    /** Optional: schedule the webhook processing for a future time. */
+    scheduledAt?: Date;
+}
+/**
+ * Convert a webhook envelope into a ScheduledWebhookJob payload
+ * suitable for enqueuing into the job queue or planned-task scheduler.
+ */
+export declare function createScheduledWebhookJob(webhookId: string, provider: WebhookProvider, envelope: WebhookMessageEnvelope, scheduledAt?: Date): ScheduledWebhookJob;
+/**
+ * Type guard for ScheduledWebhookJob payloads extracted from a job queue.
+ */
+export declare function isWebhookJob(payload: unknown): payload is ScheduledWebhookJob;
+export { createWebhookHandler, verifyGitHubSignature, verifyStripeSignature, verifyGenericAuth, safeEqual, extractWebhookContent, createWebhookEnvelope, } from "../api/webhook-triggers.js";
+export type { WebhookProvider, GitHubWebhookConfig, StripeWebhookConfig, GenericWebhookConfig, WebhookConfig, WebhookRegistration, WebhookRequest, WebhookResult, WebhookEventType, WebhookEvent, WebhookEventListener, WebhookJobQueue, WebhookHandlerConfig, WebhookHandler, WebhookMessageEnvelope, } from "../api/webhook-triggers.js";

package/dist/sdk/agent.d.ts

@@ -0,0 +1,22 @@
+import type { FenixClient } from "./client.js";
+import type { AgentOptions, AgentResult, StreamEvent } from "./types.js";
+export declare class FenixAgent {
+    private client;
+    private options;
+    private sessionId;
+    constructor(client: FenixClient, options: AgentOptions);
+    /**
+     * Run a single-turn agent completion. Returns the full result.
+     */
+    run(prompt: string): Promise<AgentResult>;
+    /**
+     * Stream a multi-turn agent session with real-time events.
+     */
+    stream(prompt: string): AsyncGenerator<StreamEvent>;
+    /**
+     * Stop the current session.
+     */
+    stop(): Promise<void>;
+    /** Get the current session ID. */
+    getSessionId(): string | null;
+}

package/dist/sdk/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/sdk/client.d.ts

@@ -0,0 +1,19 @@
+import type { FenixConfig } from "./types.js";
+export declare class FenixClient {
+    private baseUrl;
+    private apiKey;
+    private timeout;
+    constructor(config: FenixConfig);
+    request<T>(method: string, path: string, body?: unknown): Promise<T>;
+    stream(method: string, path: string, body?: unknown): AsyncGenerator<string>;
+    get(path: string): Promise<unknown>;
+    post<T>(path: string, body?: unknown): Promise<T>;
+    patch<T>(path: string, body?: unknown): Promise<T>;
+    delete(path: string): Promise<unknown>;
+}
+export declare class FenixAPIError extends Error {
+    status: number;
+    body: string;
+    path: string;
+    constructor(status: number, body: string, path: string);
+}

package/dist/sdk/index.d.ts

@@ -0,0 +1,24 @@
+import { FenixAgent } from "./agent.js";
+import { FenixJobs } from "./jobs.js";
+import { FenixMemory } from "./memory.js";
+import type { FenixConfig, AgentOptions } from "./types.js";
+export declare class Fenix {
+    private client;
+    readonly jobs: FenixJobs;
+    readonly memory: FenixMemory;
+    constructor(config: FenixConfig);
+    /**
+     * Create a headless agent session.
+     */
+    createAgent(options: AgentOptions): FenixAgent;
+}
+/**
+ * Create a Fenix SDK instance from environment variables.
+ * Reads FENIX_API_URL and FENIX_API_KEY.
+ */
+export declare function createFenix(overrides?: Partial<FenixConfig>): Fenix;
+export { FenixClient, FenixAPIError } from "./client.js";
+export { FenixAgent } from "./agent.js";
+export { FenixJobs } from "./jobs.js";
+export { FenixMemory } from "./memory.js";
+export type { FenixConfig, AgentOptions, AgentResult, StreamEvent, ToolCallRecord, JobSubmission, JobStatus, MemoryEntry, MemorySearchOptions, MemoryWriteOptions, } from "./types.js";

package/dist/sdk/jobs.d.ts

@@ -0,0 +1,25 @@
+import type { FenixClient } from "./client.js";
+import type { JobSubmission, JobStatus } from "./types.js";
+export declare class FenixJobs {
+    private client;
+    constructor(client: FenixClient);
+    /**
+     * Submit a background job.
+     */
+    submit(job: JobSubmission): Promise<JobStatus>;
+    /**
+     * Wait for a job to complete or fail.
+     */
+    wait(jobId: string, opts?: {
+        pollInterval?: number;
+        timeout?: number;
+    }): Promise<JobStatus>;
+    /**
+     * Get job status.
+     */
+    status(jobId: string): Promise<JobStatus>;
+    /**
+     * Cancel a pending or running job.
+     */
+    cancel(jobId: string): Promise<void>;
+}

package/dist/sdk/memory.d.ts

@@ -0,0 +1,18 @@
+import type { FenixClient } from "./client.js";
+import type { MemoryEntry, MemorySearchOptions, MemoryWriteOptions } from "./types.js";
+export declare class FenixMemory {
+    private client;
+    constructor(client: FenixClient);
+    /**
+     * Semantic search across memory entries.
+     */
+    search(options: MemorySearchOptions): Promise<MemoryEntry[]>;
+    /**
+     * Write a memory entry.
+     */
+    write(options: MemoryWriteOptions): Promise<MemoryEntry>;
+    /**
+     * Delete a memory entry by ID.
+     */
+    delete(id: string): Promise<void>;
+}

package/dist/sdk/types.d.ts

@@ -0,0 +1,69 @@
+export interface FenixConfig {
+    /** Fenix HTTP API base URL */
+    baseUrl: string;
+    /** API key (or set FENIX_API_KEY env var) */
+    apiKey?: string;
+    /** Request timeout in ms */
+    timeout?: number;
+}
+export interface AgentOptions {
+    workspaceId: string;
+    identity?: string;
+    tools?: string[];
+    systemPrompt?: string;
+    maxTurns?: number;
+}
+export interface AgentResult {
+    sessionId: string;
+    response: string;
+    toolCalls: ToolCallRecord[];
+    tokenUsage: {
+        input: number;
+        output: number;
+    };
+    elapsedMs: number;
+}
+export interface ToolCallRecord {
+    tool: string;
+    input: Record<string, unknown>;
+    output: unknown;
+}
+export interface StreamEvent {
+    type: "token" | "tool:start" | "tool:end" | "reasoning" | "response:final" | "error";
+    text?: string;
+    tool?: string;
+    toolInput?: Record<string, unknown>;
+    toolOutput?: unknown;
+    sessionId?: string;
+    error?: string;
+}
+export interface JobSubmission {
+    type: string;
+    payload: Record<string, unknown>;
+    priority?: number;
+}
+export interface JobStatus {
+    id: string;
+    type: string;
+    status: "pending" | "running" | "completed" | "failed";
+    result?: unknown;
+    error?: string;
+    createdAt: string;
+    completedAt?: string;
+}
+export interface MemoryEntry {
+    id: string;
+    content: string;
+    metadata?: Record<string, unknown>;
+    score?: number;
+}
+export interface MemorySearchOptions {
+    query: string;
+    topK?: number;
+    filter?: Record<string, unknown>;
+}
+export interface MemoryWriteOptions {
+    content: string;
+    metadata?: Record<string, unknown>;
+    namespace?: string;
+}