@aifight/aifight 0.1.0-alpha.1

package/dist/types/identity/identity-manager.d.ts

@@ -0,0 +1,59 @@
+import type { AgentIdentity } from "../profile/identity-schema.js";
+export type PlatformEnvironment = "local" | "beta" | "prod";
+export interface RegisterAgentOptions {
+    readonly agentSlug: string;
+    readonly displayName: string;
+    readonly model?: string;
+    readonly description?: string;
+    readonly environment: PlatformEnvironment;
+    readonly platformBaseURL: string;
+    readonly hostType?: string;
+}
+export interface RegisterAgentResult {
+    readonly agentId: string;
+    readonly apiKey: string;
+    readonly claimUrl?: string;
+    readonly claimToken?: string;
+}
+export interface IdentityStatus {
+    readonly agentSlug: string;
+    readonly hasIdentity: boolean;
+    readonly environment?: string;
+    readonly platformAgentId?: string;
+    readonly apiKeyAvailable: boolean;
+}
+export declare function getPlatformBaseURL(env: PlatformEnvironment): string;
+/**
+ * Register a new agent on the AIFight platform and store identity locally.
+ */
+export declare function registerAgent(opts: RegisterAgentOptions): Promise<{
+    identity: AgentIdentity;
+    result: RegisterAgentResult;
+}>;
+/**
+ * Load identity.json for an agent slug.
+ */
+export declare function loadIdentity(agentSlug: string): Promise<AgentIdentity | null>;
+/**
+ * Resolve the platform API key from identity's SecretRef.
+ */
+export declare function resolvePlatformApiKey(identity: AgentIdentity): Promise<string>;
+/**
+ * Check identity status without resolving secrets.
+ */
+export declare function checkIdentityStatus(agentSlug: string): Promise<IdentityStatus>;
+/**
+ * Verify platform identity by calling /api/agents/me/status.
+ */
+export declare function verifyPlatformIdentity(identity: AgentIdentity): Promise<{
+    verified: boolean;
+    agentId?: string;
+    isClaimed?: boolean;
+    error?: string;
+}>;
+/**
+ * Rotate the platform agent API key.
+ */
+export declare function rotatePlatformApiKey(agentSlug: string, ownerToken: string): Promise<{
+    newApiKey: string;
+}>;

package/dist/types/index.d.ts

@@ -0,0 +1,30 @@
+export * from "./protocol/types";
+export { findSchemasRoot, loadSchema, loadAllSchemas, loadRestSchema, messageTypes, type MessageType, type RestSchemaName, } from "./protocol/schemas";
+export { registerAgent, type RegisterAgentOptions, type RegisterAgentResult, } from "./account/registration";
+export { RegisterError, RegisterNetworkError, RegisterHttpError, RegisterSchemaError, type RegisterErrorKind, type AjvLikeError, } from "./account/errors";
+export { openDatabase, type OpenDatabaseOptions, type StoreHandle, type AgentRow, type UpsertAgentInput, } from "./store/sqlite";
+export { getRuntimeHome, getDefaultDbPath, ensureRuntimeHome, } from "./store/paths";
+export { StoreError, StoreOpenError, StoreMigrationError, StoreQueryError, type StoreErrorKind, } from "./store/errors";
+export { AIFIGHT_KEYCHAIN_V1_PREFIX, AIFIGHT_CRYPTO_V1_PREFIX, AIFIGHT_RUNTIME_SERVICE, encryptForStorage, decryptFromStorage, deleteFromStorage, isKeychainAvailable, getCredentialsBackend, type CredentialsBackendInfo, } from "./account/credentials";
+export { CredentialsError, CredentialsKeychainUnavailableError, CredentialsCryptoError, CredentialsCorruptError, type CredentialsErrorKind, } from "./account/errors";
+export { createWSClient } from "./wsclient/client";
+export type { WSClient, WSClientMessage, WSClientOptions, WSWelcome, WSCloseInfo, WSMessageHandler, WSErrorHandler, WSCloseHandler, } from "./wsclient/client";
+export type { ServerMessageEnvelope } from "./wsclient/frame-handler";
+export { WSClientError, WSConnectError, WSHandshakeError, WSWelcomeTimeoutError, WSWelcomeInvalidError, WSProtocolVersionError, WSClosedError, WSSchemaError, WSOutboundSchemaError, WSUnknownMessageError, WSAbortedError, } from "./wsclient/errors";
+export type { WSClientErrorKind } from "./wsclient/errors";
+export { createReconnectingWSClient, ReconnectStoppedError, } from "./wsclient/reconnect";
+export type { ReconnectingWSClient, ReconnectingWSClientOptions, ReconnectEvent, ReconnectEventHandler, ReconnectCloseInfo, ReconnectCloseHandler, ReconnectStopReason, JitterStrategy, } from "./wsclient/reconnect";
+export { createDirectModelProvider, DecisionProviderError, } from "./decision/provider";
+export type { DecisionProvider, DirectModelProviderOptions, DirectModelProviderName, DecisionProviderErrorKind, } from "./decision/provider";
+export type { DecisionRequest, DecisionResponse, DecisionResponseProviderMetadata, StrategyProfile, GameSpecificProfile, GameType, GameRules, LegalAction, } from "./decision/types";
+export type { ParseResult, ParseInvalidReason, } from "./decision/parser-types";
+export declare const RUNTIME_VERSION = "0.1.0-alpha.1";
+export declare const PROTOCOL_VERSION = "v1.0.0";
+export interface HelloResult {
+    ok: true;
+    runtimeVersion: string;
+    schemaCount: number;
+    messageTypeCount: number;
+    schemasRoot: string;
+}
+export declare function hello(): HelloResult;

package/dist/types/llm/adapter-registry.d.ts

@@ -0,0 +1,27 @@
+import type { LLMAdapter, LLMProtocol } from "./adapters/types.js";
+/**
+ * Register an adapter for a protocol. Overwrites any existing adapter
+ * for the same protocol (useful for testing).
+ */
+export declare function registerAdapter(adapter: LLMAdapter): void;
+/**
+ * Get the adapter for a protocol. Returns undefined if not registered.
+ */
+export declare function getAdapter(protocol: LLMProtocol | string): LLMAdapter | undefined;
+/**
+ * Get the adapter for a protocol, or throw if not registered.
+ */
+export declare function requireAdapter(protocol: LLMProtocol | string): LLMAdapter;
+/**
+ * List all registered protocol names.
+ */
+export declare function listRegisteredProtocols(): string[];
+/**
+ * Clear all registered adapters (for testing).
+ */
+export declare function clearAdapters(): void;
+/**
+ * Register all built-in P0 adapters. Called at daemon startup.
+ * Lazy-imports adapters to keep the registry module lightweight.
+ */
+export declare function registerBuiltinAdapters(): Promise<void>;

package/dist/types/llm/adapters/anthropic-messages.d.ts

@@ -0,0 +1,2 @@
+import type { LLMAdapter } from "./types.js";
+export declare function createAnthropicMessagesAdapter(): LLMAdapter;

package/dist/types/llm/adapters/deepseek-chat-completions.d.ts

@@ -0,0 +1,2 @@
+import type { LLMAdapter } from "./types.js";
+export declare function createDeepSeekChatCompletionsAdapter(): LLMAdapter;

package/dist/types/llm/adapters/openai-chat-compat.d.ts

@@ -0,0 +1,2 @@
+import type { LLMAdapter } from "./types.js";
+export declare function createOpenAIChatCompatAdapter(): LLMAdapter;

package/dist/types/llm/adapters/openai-chat-completions.d.ts

@@ -0,0 +1,2 @@
+import type { LLMAdapter } from "./types.js";
+export declare function createOpenAIChatCompletionsAdapter(): LLMAdapter;

package/dist/types/llm/adapters/openai-responses.d.ts

@@ -0,0 +1,2 @@
+import type { LLMAdapter } from "./types.js";
+export declare function createOpenAIResponsesAdapter(): LLMAdapter;

package/dist/types/llm/adapters/types.d.ts

@@ -0,0 +1,128 @@
+export type ReasoningEffort = "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max" | "auto";
+export interface CanonicalReasoningConfig {
+    readonly enabled?: boolean | "auto";
+    readonly mode?: "disabled" | "enabled" | "adaptive" | "auto";
+    readonly effort?: ReasoningEffort;
+    readonly budgetTokens?: number | null;
+    readonly taskBudgetTokens?: number | null;
+    readonly thinkingLevel?: "minimal" | "low" | "medium" | "high" | null;
+    readonly thinkingBudget?: number | null;
+    readonly display?: "omitted" | "summarized" | null;
+    readonly summary?: "off" | "auto" | "concise" | "detailed" | null;
+    readonly includeEncryptedReasoning?: boolean;
+}
+export declare const SUPPORTED_PROTOCOLS: readonly ["anthropic_messages", "openai_responses", "openai_chat_completions", "openai_chat_compat", "deepseek_chat_completions", "gemini_generate_content", "gemini_openai_compat"];
+export type LLMProtocol = (typeof SUPPORTED_PROTOCOLS)[number];
+export interface DecisionInput {
+    /** System prompt assembled from soul + strategy + rules + context */
+    readonly systemPrompt: string;
+    /** User prompt with current state + legal actions + output contract */
+    readonly userPrompt: string;
+    /** Max output tokens for this decision */
+    readonly maxTokens: number;
+    /** Temperature (null = provider default) */
+    readonly temperature: number | null;
+    /** Canonical reasoning config (adapter translates to provider format) */
+    readonly reasoning?: CanonicalReasoningConfig;
+    /** Response format hint */
+    readonly responseFormat?: "json" | "json_object" | "json_schema" | "text";
+    /** Abort signal for timeout */
+    readonly signal?: AbortSignal;
+}
+export interface DecisionOutput {
+    /** Raw text response from the model */
+    readonly text: string;
+    /** Input tokens used */
+    readonly inputTokens?: number;
+    /** Output tokens used (includes reasoning tokens for some providers) */
+    readonly outputTokens?: number;
+    /** Reasoning/thinking tokens (if separately reported) */
+    readonly reasoningTokens?: number;
+    /** Cached tokens (if provider reports) */
+    readonly cachedTokens?: number;
+    /** Response latency in ms */
+    readonly latencyMs: number;
+    /** Short reasoning summary if provider supports it */
+    readonly reasoningSummary?: string;
+    /** Raw provider response (for debugging, usually redacted before storage) */
+    readonly raw?: unknown;
+    /** Provider-specific continuation state to preserve within this match session */
+    readonly continuationState?: unknown;
+}
+export interface UsageRecord {
+    readonly protocol: string;
+    readonly providerLabel: string;
+    readonly model: string;
+    readonly inputTokens?: number;
+    readonly outputTokens?: number;
+    readonly reasoningTokens?: number;
+    readonly cachedTokens?: number;
+    readonly estimatedCostUSD?: number;
+    readonly latencyMs: number;
+    readonly timestamp: string;
+}
+export interface ProbeResult {
+    readonly success: boolean;
+    readonly latencyMs: number;
+    readonly error?: string;
+    readonly model: string;
+    readonly protocol: string;
+    /** Whether the model returned valid JSON when asked */
+    readonly jsonValid?: boolean;
+}
+export interface ValidationResult {
+    readonly ok: boolean;
+    readonly errors: string[];
+    readonly warnings: string[];
+}
+export interface LLMProfile {
+    readonly profileId: string;
+    readonly displayName: string;
+    readonly protocol: LLMProtocol;
+    readonly baseURL: string;
+    readonly model: string;
+    readonly apiKey: string;
+    readonly temperature: number | null;
+    readonly maxTokens: number;
+    readonly responseFormat?: string;
+    readonly reasoning?: CanonicalReasoningConfig;
+    readonly timeouts: {
+        readonly requestMs: number;
+        readonly connectMs: number;
+    };
+    readonly retries: {
+        readonly maxAttempts: number;
+        readonly backoffMs: number;
+    };
+    readonly budgets?: {
+        readonly maxCostUSDPerMatch?: number;
+        readonly maxCostUSDPerDay?: number;
+        readonly maxOutputTokensPerDecision?: number;
+    };
+}
+export interface LLMAdapter {
+    /** Protocol this adapter handles */
+    readonly protocol: LLMProtocol;
+    /** Validate a profile against this adapter's capabilities */
+    validateProfile(profile: LLMProfile): ValidationResult;
+    /** Make a probe/test call to verify connectivity and JSON response */
+    probe(profile: LLMProfile): Promise<ProbeResult>;
+    /** Build and send a decision request, return parsed output */
+    generateDecision(input: DecisionInput, profile: LLMProfile, continuationState?: unknown): Promise<DecisionOutput>;
+    /** Estimate cost from a completed response */
+    estimateUsage(output: DecisionOutput, profile: LLMProfile): UsageRecord;
+    /** Redact sensitive data from raw provider response */
+    redact(raw: unknown): unknown;
+}
+export type AdapterErrorKind = "auth_failed" | "rate_limited" | "model_not_found" | "invalid_request" | "server_error" | "timeout" | "network" | "aborted" | "invalid_response" | "unsupported" | "budget_exceeded" | "unknown";
+export declare class AdapterError extends Error {
+    readonly name = "AdapterError";
+    readonly kind: AdapterErrorKind;
+    readonly protocol: string;
+    readonly retryable: boolean;
+    readonly cause: unknown;
+    constructor(kind: AdapterErrorKind, protocol: string, message: string, opts?: {
+        retryable?: boolean;
+        cause?: unknown;
+    });
+}

package/dist/types/llm/capabilities/validate-capabilities.d.ts

@@ -0,0 +1,68 @@
+export interface ModelCapability {
+    /** Regex pattern matched against the model string (e.g. "^claude-opus-4-7"). */
+    pattern: string;
+    /** Thinking modes the model accepts, e.g. ["adaptive"]. */
+    thinkingModes?: string[];
+    /** Effort levels accepted by this specific model (subset of protocol effortValues). */
+    efforts?: string[];
+    /** Per-model default effort override (falls back to protocol defaultEffort). */
+    defaultEffort?: string;
+    /** True if the model accepts a manual budget_tokens parameter. */
+    supportsManualBudget?: boolean;
+    /** False if the model ignores temperature even when the protocol supports it. */
+    supportsTemperature?: boolean;
+    /** True if temperature/top_p are silently ignored in thinking mode. */
+    samplingIgnoredWhenThinking?: boolean;
+    /** Maximum output tokens the model can produce. */
+    maxOutputTokens: number;
+    /** Protocol-specific thinking API parameter name, e.g. "thinkingLevel" | "thinkingBudget". */
+    thinkingParam?: string;
+    /** Free-text notes for operators. Not used in validation logic. */
+    notes?: string;
+}
+export interface ProtocolCapability {
+    displayName: string;
+    defaultBaseURL: string;
+    supportsBaseURL: boolean;
+    /** true | false | "ignored_when_thinking" */
+    supportsTemperature: boolean | string;
+    supportsJSONMode: boolean;
+    supportsThinking: boolean;
+    supportsReasoningSummary: boolean;
+    /** Request parameter name for the token limit, e.g. "max_tokens". */
+    maxTokensParam: string;
+    /** All effort levels the protocol understands. */
+    effortValues: string[];
+    defaultEffort?: string;
+    /** Optional effort remapping for protocols with a restricted effort vocabulary. */
+    compatEffortMap?: Record<string, string>;
+    models: ModelCapability[];
+    notes?: string;
+}
+export interface CapabilityRegistry {
+    schemaVersion: number;
+    protocols: Record<string, ProtocolCapability>;
+}
+export interface ThinkingConfig {
+    /** "adaptive" | "enabled" | "disabled" or protocol-specific value */
+    mode?: string;
+    /** Explicit budget_tokens (only for protocols/models that support manual budget). */
+    budgetTokens?: number;
+    /** "low" | "medium" | "high" | "xhigh" | "max" | "none" | "minimal" */
+    effort?: string;
+}
+export declare function loadCapabilityRegistry(): CapabilityRegistry;
+export declare function validateProfileAgainstCapabilities(protocol: string, model: string, thinking: ThinkingConfig | undefined, registry: CapabilityRegistry): {
+    ok: true;
+} | {
+    ok: false;
+    errors: string[];
+    warnings: string[];
+};
+export declare function getDefaultBaseURL(protocol: string, registry: CapabilityRegistry): string | undefined;
+export declare function mapEffortForProtocol(effort: string, protocol: string, registry: CapabilityRegistry): {
+    mapped: string;
+    warning?: string;
+} | {
+    error: string;
+};

package/dist/types/mcp/control-client.d.ts

@@ -0,0 +1,54 @@
+export interface ControlClientPaths {
+    tokenPath: string;
+    portPath: string;
+}
+export interface ControlCredentials {
+    token: string;
+    port: number;
+}
+export interface RequestOptions {
+    method?: "GET" | "POST" | "DELETE" | "PUT" | "PATCH";
+    body?: unknown;
+    signal?: AbortSignal;
+}
+export type FetchLike = (input: string, init?: RequestInit) => Promise<Response>;
+export interface ControlClientOptions {
+    paths?: ControlClientPaths;
+    fetch?: FetchLike;
+    /**
+     * Per-request timeout (covers fetch headers + body read). Default
+     * 10000ms — same baseline as the M1 CLI control-client. Tests inject
+     * a small value (e.g. 50ms) to assert the timeout path without
+     * waiting in real time.
+     */
+    baseTimeoutMs?: number;
+}
+export interface ControlClient {
+    request<T = unknown>(path: string, opts?: RequestOptions): Promise<T>;
+}
+/**
+ * Discriminated kind for RuntimeUnavailableError. Used by mcp/tools.ts
+ * to emit a whitelist user-facing message that does NOT echo the raw
+ * fetch error / URL / port — those would leak via MCP `text` content
+ * which the host typically records and uploads to telemetry.
+ */
+export type RuntimeUnavailableKind = "unreachable" | "timeout" | "unauthorized" | "files_corrupt" | "other";
+export declare class RuntimeUnavailableError extends Error {
+    readonly name = "RuntimeUnavailableError";
+    readonly kind: RuntimeUnavailableKind;
+    readonly attempts: number;
+    constructor(kind: RuntimeUnavailableKind, message: string, attempts: number, options?: ErrorOptions);
+}
+export declare function getDefaultControlClientPaths(homedir?: string): ControlClientPaths;
+/**
+ * Non-retryable HTTP error from the controlapi (4xx/5xx other than 401).
+ * Tool handlers turn this into a structured `{isError:true}` MCP
+ * result so the client sees a tool-level error.
+ */
+export declare class ControlHttpError extends Error {
+    readonly name = "ControlHttpError";
+    readonly status: number;
+    readonly bodyText: string;
+    constructor(status: number, bodyText: string);
+}
+export declare function createControlClient(opts?: ControlClientOptions): ControlClient;

package/dist/types/mcp/profile-tools.d.ts

@@ -0,0 +1,10 @@
+import { type ControlClient } from "./control-client.js";
+import type { McpTool, McpToolResult } from "./tools.js";
+export declare const PROFILE_TOOLS: readonly McpTool[];
+export declare const PROFILE_TOOL_NAMES: string[];
+/**
+ * Dispatch a profile tool call by name.
+ * Returns a structured McpToolResult — never throws.
+ * Call this from mcp/server.ts CallTool handler after checking MCP_TOOL_NAMES.
+ */
+export declare function handleProfileTool(client: ControlClient, name: string, args: Record<string, unknown>): Promise<McpToolResult>;

package/dist/types/mcp/server.d.ts

@@ -0,0 +1,10 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { type McpServerOptions } from "./types.js";
+export declare function createMcpServer(opts?: McpServerOptions): Server;
+/**
+ * Spawn the MCP server bound to the process's stdio. Returns the
+ * connected server instance — the caller is expected to keep the
+ * process alive (the SDK handles JSON-RPC dispatch via its own event
+ * loop). Caller may call `server.close()` for graceful shutdown.
+ */
+export declare function runMcpServer(opts?: McpServerOptions): Promise<Server>;

package/dist/types/mcp/tools.d.ts

@@ -0,0 +1,31 @@
+import { type ControlClient } from "./control-client.js";
+export interface McpToolResult {
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+    isError?: boolean;
+}
+export interface McpTool {
+    readonly name: string;
+    readonly description: string;
+    readonly inputSchema: Record<string, unknown>;
+    readonly handler: (client: ControlClient, args: Record<string, unknown>) => Promise<McpToolResult>;
+}
+/**
+ * M5-13 B7 — `ping` is intercepted by mcp/server.ts BEFORE registry
+ * dispatch, because the response includes daemon-independent uptime_ms
+ * which only the server-construction path knows. The metadata is
+ * exported separately (not in MCP_TOOLS) so ListTools can still
+ * advertise it without keeping a dead handler stub in the registry.
+ *
+ * Sealed contract: ListTools must return ping FIRST in the tool list;
+ * see runtime/tests/mcp-tools.test.ts:87 for the order assertion.
+ */
+export declare const PING_METADATA: {
+    name: "ping";
+    description: string;
+    inputSchema: Record<string, unknown>;
+};
+export declare const MCP_TOOLS: readonly McpTool[];
+export declare const MCP_TOOL_NAMES: string[];

package/dist/types/mcp/types.d.ts

@@ -0,0 +1,27 @@
+import type { ControlClient } from "./control-client.js";
+export declare const MCP_SERVER_NAME = "aifight";
+/**
+ * Re-export of the canonical tool-name list. Sourced from tools.ts so
+ * the MCP_TOOL_NAMES constant stays in lockstep with MCP_TOOLS itself.
+ * (M3-01 had this constant local; M3-02 promotes it to tools.ts because
+ *  the tool definitions are now the source of truth.)
+ */
+export { MCP_TOOL_NAMES } from "./tools.js";
+export interface McpServerOptions {
+    /** Override the server name (default "aifight"). */
+    serverName?: string;
+    /** Server version reported on initialize handshake. */
+    version?: string;
+    /**
+     * Used by `ping` to compute uptime_ms. Defaults to `Date.now()`
+     * at construction time. Tests inject a fixed value so the uptime
+     * assertion is deterministic.
+     */
+    startedAtMs?: number;
+    /**
+     * (M3-02) HTTP client to the local controlapi. When omitted,
+     * controlapi-bound tools (everything except `ping`) return
+     * isError:true with a message telling the user to start the daemon.
+     */
+    controlClient?: ControlClient;
+}