import { WebJobProgress } from "@xenosystem/web-context-client/progress";
interface FileSnapshot {
    path: string;
    exists: boolean;
    size: number;
    mtimeMs: number;
    text?: string;
    binary?: boolean;
    truncated?: boolean;
}
interface TurnFileDiff {
    path: string;
    status: "created" | "modified" | "deleted" | "unchanged";
    before?: FileSnapshot;
    after?: FileSnapshot;
    patch?: string;
}
interface TurnDiffSummary {
    turnId: string;
    startedAt: string;
    completedAt: string;
    files: TurnFileDiff[];
}
interface TurnDiffTrackerOptions {
    maxFileBytes?: number;
    cwd?: string;
}
declare class TurnDiffTracker {
    private active?;
    private readonly maxFileBytes;
    private readonly cwd;
    constructor(options?: TurnDiffTrackerOptions);
    beginTurn(turnId: string): void;
    observeBefore(paths: Iterable<string | null | undefined>): void;
    observeAfter(paths: Iterable<string | null | undefined>): void;
    endTurn(): TurnDiffSummary | undefined;
    inferToolPaths(toolName: string, input: Record<string, unknown>): string[];
    private resolvePath;
    private snapshot;
}
interface ProviderTransportLimits {
    connectTimeoutMs?: number;
    totalTimeoutMs?: number;
    idleTimeoutMs?: number;
    maxResponseBytes?: number;
    maxHeaderBytes?: number;
    maxEventBytes?: number;
}
type TokenEstimator = (text: string, model: string) => number;
type TokenAccountingSource = "exact" | "provider-reported" | "estimated";
interface TokenAccountingAdapter {
    readonly id: string;
    readonly source: Exclude<TokenAccountingSource, "provider-reported">;
    countText(text: string, model: string): number;
    countImage?(input: {
        model: string;
        detail?: "auto" | "low" | "high";
    }): number;
    safetyMarginRatio?(model: string): number;
}
interface CompactionRecord {
    schemaVersion: 1;
    source: {
        firstMessageId: string;
        lastMessageId: string;
        messageIds: string[];
        digest: string;
    };
    protectedMessageIds: string[];
    appliedPruningTiers: string[];
    summary: {
        messageId: string;
        promptVersion: "xeno-context-summary-v1";
        provider?: string;
        model: string;
    };
    accounting: {
        beforeTokens: number;
        afterTokens: number;
        source: TokenAccountingSource;
        adapterId: string;
    };
    artifactReferences: string[];
    createdAt: string;
}
declare const WEB_CONTEXT_TOOL_RESULT_SCHEMA: "xeno.web-context.tool-result.v1";
interface WebContextEvidenceProjection {
    evidenceId: string;
    requestId: string;
    sourceUrl: string;
    finalUrl?: string;
    citations: Array<{
        url: string;
        title?: string;
        artifactId?: string;
    }>;
}
interface WebContextToolResult {
    schemaVersion: typeof WEB_CONTEXT_TOOL_RESULT_SCHEMA;
    operation: "search" | "fetch";
    requestId: string;
    evidence: WebContextEvidenceProjection;
    job?: {
        jobId: string;
        state: string;
    };
    artifact?: {
        artifactId: string;
        mediaType: string;
        bytes: number;
    };
    jobProgress?: WebJobProgress;
}
type PermissionProfileName = "default" | "read-only" | "trusted-dev";
type PermissionProfileDecision = "allow" | "ask" | "deny";
type PermissionProfileMode = "default" | "acceptEdits" | "bypassPermissions" | "auto";
interface PermissionProfile {
    schemaVersion: 1;
    name: PermissionProfileName;
    displayName: string;
    description: string;
    permissionMode: PermissionProfileMode;
    filesystem: {
        scope: "workspace" | "workspace-readonly" | "unrestricted";
        read: PermissionProfileDecision;
        write: PermissionProfileDecision;
        allowedPaths: string[];
        deniedPaths: string[];
    };
    shell: {
        default: PermissionProfileDecision;
        allowedCommands: string[];
        deniedCommands: string[];
    };
    network: {
        default: PermissionProfileDecision;
        allowDomains: string[];
        denyDomains: string[];
    };
    mcp: {
        remoteServers: PermissionProfileDecision;
        allowedServers: string[];
        deniedServers: string[];
    };
    lsp: {
        enabled: boolean;
        diagnostics: PermissionProfileDecision;
        navigation: PermissionProfileDecision;
        startProcesses: PermissionProfileDecision;
    };
}
interface ToolDefinition {
    name: string;
    description: string;
    input_schema: {
        type: "object";
        properties: Record<string, unknown>;
        required?: string[];
        additionalProperties?: boolean | Record<string, unknown>;
        [keyword: string]: unknown;
    };
}
interface ImageUrlBlock {
    type: "image_url";
    image_url: {
        url: string;
        detail?: "auto" | "low" | "high";
    };
}
interface ResourceContentBlock {
    type: "resource";
    uri?: string;
    mimeType?: string;
    text?: string;
    data?: string;
}
type ToolAssistantContentBlock = TextBlock | ImageUrlBlock | ResourceContentBlock;
type ToolResultContent = string | ToolAssistantContentBlock[];
type ToolOperationState = "registered" | "starting" | "running_foreground" | "running_background" | "waiting_for_input" | "stalled" | "verifying" | "completed" | "failed" | "timed_out" | "cancelled" | "orphaned";
type ToolCompletionPolicy = "await" | "observe" | "detach";
interface ExpectedOutputContract {
    path: string;
    kind?: "file" | "directory";
    nonEmpty?: boolean;
}
interface ToolEvidence {
    id: string;
    kind: "artifact" | "process" | "verification";
    status: "pending" | "verified" | "failed";
    path?: string;
    observedAt: string;
    operationId: string;
    detail?: Record<string, string | number | boolean | null>;
}
interface ToolOperationSnapshot {
    schemaVersion: 1;
    operationId: string;
    turnId: string;
    generation: number;
    toolCallId: string;
    toolName: string;
    ownerSessionId?: string;
    state: ToolOperationState;
    terminal: boolean;
    presentation: "foreground" | "background";
    completionPolicy: ToolCompletionPolicy;
    promotable: boolean;
    processId?: string;
    taskId?: string;
    displayName?: string;
    pid?: number;
    commandFingerprint?: string;
    outputPath?: string;
    startedAt: string;
    lastActivityAt: string;
    deadlineAt?: string;
    elapsedMs: number;
    idleMs: number;
    outputBytes: number;
    nextOffset: number;
    exitCode?: number | null;
    completionReason?: string;
    suggestedNextAction?: string;
    expectedOutputs?: ExpectedOutputContract[];
    evidence?: ToolEvidence[];
}
interface ToolProgressUpdate {
    activity?: "stdout" | "stderr" | "input" | "waiting_for_input" | "heartbeat" | "state";
    message?: string;
    bytes?: number;
    outputBytes?: number;
    nextOffset?: number;
    webContextProgress?: WebJobProgress;
}
interface ToolAuthorizationReceipt {
    turnId: string;
    toolCallId: string;
    toolName: string;
    iteration: number;
    policy: {
        allowed: true;
        reason: string;
        temporaryOverride: boolean;
    };
    permission: {
        allowed: true;
        reason: string;
    };
}
interface ToolResult {
    success: boolean;
    output: string;
    error?: string;
    errorCode?: string;
    errorDetails?: Record<string, unknown>;
    assistantContent?: ToolAssistantContentBlock[];
    assistantOnlyContent?: ToolAssistantContentBlock[];
    operation?: ToolOperationSnapshot;
    evidence?: ToolEvidence[];
    webContext?: WebContextToolResult;
    retryable?: boolean;
}
interface ToolExecutionContext {
    signal?: AbortSignal;
    operationId?: string;
    reportProgress?: (event: ToolProgressUpdate) => void;
    authorization?: ToolAuthorizationReceipt;
}
type ToolExecutor = (input: Record<string, unknown>, context?: ToolExecutionContext) => Promise<ToolResult>;
interface ToolPolicyProjection {
    observabilityInput: Record<string, unknown>;
    permissionInput: Record<string, unknown>;
    permissionPreview?: string;
    approvalKey?: string;
    riskLevel?: "low" | "medium" | "high";
}
interface RegisteredTool {
    definition: ToolDefinition;
    execute: ToolExecutor;
    projectPolicyInput?: (input: Record<string, unknown>) => ToolPolicyProjection | {
        error: ToolResult;
    };
}
interface TextBlock {
    type: "text";
    text: string;
}
interface ToolUseBlock {
    type: "tool_use";
    id: string;
    name: string;
    input: Record<string, unknown>;
    provider_metadata?: Record<string, unknown>;
}
interface ToolResultBlock {
    type: "tool_result";
    tool_use_id: string;
    content: string;
    assistant_content?: ToolAssistantContentBlock[];
    assistant_only_content?: ToolAssistantContentBlock[];
    is_error?: boolean;
    operation?: ToolOperationSnapshot;
    evidence?: ToolEvidence[];
    web_context?: WebContextToolResult;
    retryable?: boolean;
}
type ContentBlock = TextBlock | ToolUseBlock;
interface DirectShellResultRecord {
    kind: "direct_shell_result";
    origin: "user_direct_shell";
    command: string;
    cwd: string;
    taskId: string;
    processId?: string;
    presentation: "foreground" | "background";
    status: "running" | "completed" | "failed" | "terminated";
    exitCode: number | null;
    completionReason?: "exit" | "timeout" | "terminated" | "output_limit" | "spawn_error";
    elapsedMs: number;
    output: string;
    outputBytes: number;
    outputTruncated: boolean;
    omittedChars?: number;
    recordedAt: string;
}
interface DirectShellMessageMetadata {
    source: "direct_shell";
    directShell: DirectShellResultRecord;
}
interface Message {
    id?: string;
    role: "user" | "assistant";
    content: string | ContentBlock[] | ToolResultBlock[];
    metadata?: DirectShellMessageMetadata;
}
type PermissionDecision = "allow" | "ask" | "deny";
type ExecutionMode = "agent" | "chatOnly";
declare const AGENT_EFFORT_LEVELS: readonly [
    "low",
    "medium",
    "high",
    "xhigh",
    "max"
];
type AgentEffortLevel = (typeof AGENT_EFFORT_LEVELS)[number];
interface PermissionRule {
    tool: string;
    pattern?: string;
    decision: PermissionDecision;
}
interface PermissionConfig {
    mode: "default" | "acceptEdits" | "bypassPermissions" | "plan" | "auto";
    rules: PermissionRule[];
    profile?: PermissionProfile;
}
type PermissionPromptOperation = "generic" | "filesystem" | "write" | "edit" | "bash";
interface PermissionPromptPreviewLine {
    kind: "meta" | "context" | "add" | "remove";
    text: string;
}
interface PermissionPromptPreview {
    title: string;
    summary?: string;
    lines: PermissionPromptPreviewLine[];
    truncated?: boolean;
}
interface PermissionPromptInfo {
    toolName: string;
    detail: string;
    description?: string;
    operation?: PermissionPromptOperation;
    preview?: PermissionPromptPreview;
    commandPrefix?: string;
    approvalKey?: string;
    requesterLabel?: string;
    requesterSummary?: string;
    directory?: string;
    filePath?: string;
}
type PermissionPromptFn = (info: PermissionPromptInfo) => Promise<"allow" | "always" | "deny">;
type SessionStatus = "creating" | "active" | "paused" | "completed" | "abandoned" | "archived";
interface AgentSessionHostBindingV1 {
    schemaVersion: 1;
    conversationId: string;
    hostStorageIdentity: string;
}
interface SessionMeta {
    id: string;
    role: string;
    name?: string;
    status: SessionStatus;
    createdAt: string;
    updatedAt: string;
    lastActivity: string;
    workingDirectory: string;
    model: string;
    executionMode?: ExecutionMode;
    parentSession?: string;
    checkpoints: string[];
    messageCount: number;
    tokenUsage: {
        input: number;
        output: number;
        total: number;
    };
    formatVersion?: number;
    hostBinding?: AgentSessionHostBindingV1;
    pinned?: boolean;
    pinnedAt?: string;
}
type TranscriptEventType = "session_start" | "user_message" | "assistant_message" | "tool_call" | "tool_result" | "delegation_summary" | "checkpoint" | "context_compressed" | "session_end" | "error";
interface SessionStartData {
    sessionId: string;
    role: string;
    model: string;
    workingDirectory: string;
    formatVersion?: number;
    forkedFrom?: string;
    checkpointId?: string;
}
interface ToolCallData {
    toolName: string;
    input: Record<string, unknown>;
}
interface ToolResultData {
    toolName: string;
    success: boolean;
    output: string;
    error?: string;
    assistantContent?: ToolAssistantContentBlock[];
    assistantOnlyContent?: ToolAssistantContentBlock[];
}
interface CheckpointData {
    id?: string;
    checkpointId?: string;
    action?: "create" | "restore" | "delete";
    name?: string;
    trigger?: CheckpointTrigger;
    messageCount: number;
}
interface DelegationSummaryData {
    selectedRole?: string;
    selectedTaskId?: string;
    elapsedMs: number;
    totalTokens: number;
    okBranches: number;
    errorBranches: number;
    totalBranches: number;
    roleSummaries: Record<string, {
        status: "ok" | "error" | "timeout";
        tokensUsed: number;
        outputPreview?: string;
        error?: string;
    }>;
}
interface ContextCompressedData {
    messagesRemoved: number;
    tokensSaved: number;
    compaction?: CompactionRecord;
    activeContextMessages?: Message[];
}
interface SessionEndData {
    reason: "user_exit" | "error" | "completed";
    messageCount: number;
    totalTokens: number;
}
interface ErrorData {
    message: string;
    code?: string;
    stack?: string;
}
type TranscriptEventData = {
    type: "session_start";
    data: SessionStartData;
} | {
    type: "user_message";
    data: Message;
} | {
    type: "assistant_message";
    data: Message;
} | {
    type: "tool_call";
    data: ToolCallData;
} | {
    type: "tool_result";
    data: ToolResultData;
} | {
    type: "delegation_summary";
    data: DelegationSummaryData;
} | {
    type: "checkpoint";
    data: CheckpointData;
} | {
    type: "context_compressed";
    data: ContextCompressedData;
} | {
    type: "session_end";
    data: SessionEndData;
} | {
    type: "error";
    data: ErrorData;
};
interface TranscriptEvent {
    id: string;
    type: TranscriptEventType;
    timestamp: string;
    sequence: number;
    data: TranscriptEventData["data"];
    tokenCount?: number;
}
type CheckpointTrigger = "auto" | "manual" | "pre_dangerous" | "milestone";
interface CheckpointInfo {
    id: string;
    name?: string;
    trigger: CheckpointTrigger;
    createdAt: string;
    messageCount: number;
    tokenCount: number;
}
interface PermissionRequestContext {
    toolName: string;
    path: string;
    directory: string;
    reason: string;
}
interface PermissionRequestResult {
    granted: boolean;
    allowedDirectory?: string;
}
interface AgentCapabilities {
    terminal: boolean;
    fileRead: boolean;
    fileWrite: boolean;
    appLaunch: boolean;
}
type ExecutionSecurityLevel = "policy-only" | "process-hardened" | "contained";
type ExecutionTrustMode = "trusted-workspace" | "untrusted";
interface ContainmentCertificationBinding {
    manifestPath: string;
    candidateSha256: string;
    expectedCertificationId?: string;
    trustedPublicKeys: Record<string, string>;
}
interface PolicyEnforcerConfig {
    allowedDirectories: string[];
    workingDirectory?: string;
    capabilities: AgentCapabilities;
    executionLevel?: ExecutionSecurityLevel;
    trustMode?: ExecutionTrustMode;
    requireOsContainment?: boolean;
    allowNetwork?: boolean;
    containmentCertification?: ContainmentCertificationBinding;
    deniedDirectories?: string[];
    containedEnvironmentAllowlist?: string[];
    temporaryDirectories?: string[];
    workspace?: {
        id: string;
        name: string;
    };
    team?: {
        id: string;
        name: string;
    };
}
type AgentSandbox = PolicyEnforcerConfig;
interface ToolRegistryOptions {
    validateInputs?: boolean;
    toolSchemaMode?: "all" | "demand";
}
declare class ToolRegistry {
    private tools;
    private compiledSchemas;
    private changeListeners;
    private aliasNames;
    private validateInputs;
    private readonly toolSchemaMode;
    private readonly activatedDefinitions;
    constructor(options?: ToolRegistryOptions);
    setValidateInputs(enabled: boolean): this;
    get inputValidationEnabled(): boolean;
    get schemaLoadingMode(): "all" | "demand";
    register(tool: RegisteredTool): void;
    registerAlias(tool: RegisteredTool): void;
    registerAll(tools: Iterable<RegisteredTool>): void;
    unregister(name: string): boolean;
    onChange(listener: () => void): () => void;
    private emitChange;
    get(name: string): RegisteredTool | undefined;
    getDefinitions(): ToolDefinition[];
    getDefinitionsForRequest(): ToolDefinition[];
    getCapabilityCatalog(): string;
    activateMatchingDefinitions(query: string, limit?: number): ToolDefinition[];
    private static namespaceOf;
    getDefinitionsByNamespace(namespace: string): ToolDefinition[];
    listNamespaces(): string[];
    execute(name: string, input: Record<string, unknown>, context?: ToolExecutionContext): Promise<ToolResult>;
    listNames(): string[];
    has(name: string): boolean;
    projectPolicyInput(name: string, input: Record<string, unknown>): ToolPolicyProjection | {
        error: ToolResult;
    };
    get size(): number;
    private compileDefinition;
    private assertDefinitionsExportable;
}
interface PermissionDecisionEvent {
    traceId?: string;
    toolName: string;
    input: Record<string, unknown>;
    allowed: boolean;
    reason: string;
    mode: PermissionConfig["mode"];
    requesterLabel?: string;
}
type PermissionDecisionHook = (event: PermissionDecisionEvent) => Promise<void> | void;
interface AutoPermissionDecision {
    decision: PermissionDecision;
    confidence: "low" | "medium" | "high";
    reason: string;
    risk: "none" | "low" | "medium" | "high" | "critical";
    matchedRules: string[];
    classifierModel?: string;
    classifierTraceId?: string;
}
interface PersistentPermissionState {
    allowedTools?: string[];
    allowedDirectories?: string[];
}
interface PermissionCheckContext {
    traceId?: string;
    requesterLabel?: string;
    ephemeralInputPreview?: string;
    onWaitStart?: () => void;
    onWaitEnd?: () => void;
}
declare class PermissionEngine {
    private config;
    private workingDirectory;
    private sessionAllowed;
    private sessionAllowedDirectories;
    private persistentAllowed;
    private persistentAllowedDirectories;
    private promptFn?;
    private decisionHook?;
    constructor(config?: Partial<PermissionConfig>, promptFn?: PermissionPromptFn, decisionHook?: PermissionDecisionHook);
    fork(promptFn?: PermissionPromptFn | undefined): PermissionEngine;
    get mode(): PermissionConfig["mode"];
    setMode(mode: PermissionConfig["mode"]): void;
    setWorkingDirectory(cwd: string): void;
    setRules(rules: PermissionConfig["rules"]): void;
    loadPersistentState(state: PersistentPermissionState): void;
    allowDirectory(directory: string): void;
    isPathInAllowedDirectory(filePath: string): boolean;
    check(toolName: string, input: Record<string, unknown>, context?: PermissionCheckContext): Promise<{
        allowed: boolean;
        reason: string;
    }>;
    private finalizeDecision;
    classifyAutoPermission(toolName: string, input: Record<string, unknown>): AutoPermissionDecision;
    private contentDigest;
    private hasShellComposition;
    private getCacheKey;
    private isPathInPersistentAllowedDirectory;
    private normalizePersistentApprovalKey;
    private extractFilePath;
    private extractDirectory;
    private normalizeDirectory;
    private promptUser;
    private getToolDetail;
    private getCommandPrefix;
    private matchesRule;
    private matchesBashPattern;
    private matchesWildcard;
    private isCredentialLikePath;
    private isDangerousAutoBashCommand;
    private isLowRiskAutoBashCommand;
    private hasBashApproval;
    private extractBashCommandPrefix;
    private normalizeCommandText;
    private resolveTargetPath;
}
type ToolFailureCategory = "schema" | "missing_path" | "permission_denied" | "transport" | "timeout" | "tool_failure";
interface ToolFailureGuardTrip {
    category: ToolFailureCategory;
    reason: "exact_signature" | "semantic_schema" | "target_cycle" | "category_streak" | "short_cycle";
    toolName: string;
    attempts: number;
    cycleLength?: number;
    errorFingerprint: string;
    targetFingerprint?: string;
    lastError: string;
}
interface ApiTextContentBlock {
    type: "text";
    text: string;
}
interface ApiToolUseContentBlock {
    type: "tool_use";
    id: string;
    name: string;
    input: Record<string, unknown>;
    provider_metadata?: Record<string, unknown>;
}
interface ApiToolResultContentBlock {
    type: "tool_result";
    tool_use_id: string;
    content: ToolResultContent;
    assistant_content?: ToolAssistantContentBlock[];
    assistant_only_content?: ToolAssistantContentBlock[];
    is_error?: boolean;
}
type ApiMessage = {
    role: "user" | "assistant";
    content: string | Array<ApiTextContentBlock | ApiToolUseContentBlock | ApiToolResultContentBlock>;
};
type XenoChatMessage = {
    role: "system" | "user" | "assistant" | "tool";
    content: string | null | Array<{
        type: "text";
        text: string;
    } | {
        type: "image_url";
        image_url: {
            url: string;
            detail?: "auto" | "low" | "high";
        };
    }>;
    tool_call_id?: string;
    tool_calls?: Array<{
        id: string;
        type: "function";
        function: {
            name: string;
            arguments: string;
        };
    }>;
};
interface StreamResult {
    content: ContentBlock[];
    stopReason: "end_turn" | "tool_use" | "max_tokens" | "stop_sequence";
    inputTokens: number;
    outputTokens: number;
    usageReported: boolean;
}
interface ApiRequestFailureDiagnostics {
    model: string;
    requestUrl: string;
    stream: boolean;
    messageCount: number;
    toolCount: number;
    requestBytes: number;
    promptTokenEstimate: number;
    statusCode?: number;
    requestId?: string;
    cfRay?: string;
    retryAfterMs?: number;
    detailPreview?: string;
    errorMessage?: string;
}
interface LlmClientDeps {
    readonly baseURL: string;
    readonly ollamaBaseUrl: string;
    readonly localRuntimeProtocol?: "openai-chat" | "ollama-native";
    readonly localTransportLimits?: ProviderTransportLimits;
    readonly apiKey?: string;
    authorizeRequest?(target: {
        method: string;
        url: string;
    }): Promise<{
        authorization: string;
        dpop?: string;
    } | null>;
    readonly maxTokens: number;
    getApiRequestTimeoutMs(): number;
    buildRuntimeSystemPrompt(): string;
    reportFailure(diagnostics: ApiRequestFailureDiagnostics): Promise<void>;
}
declare class LlmClient {
    private readonly deps;
    constructor(deps: LlmClientDeps);
    readonly id = "xeno-llm-client";
    complete(model: string, messages: ApiMessage[], tools: ToolDefinition[], onText?: (text: string) => void, signal?: AbortSignal): Promise<StreamResult>;
    completeLocal(model: string, messages: ApiMessage[], tools: ToolDefinition[], onText?: (text: string) => void, signal?: AbortSignal): Promise<StreamResult>;
    toOllamaMessages(apiMessages: ApiMessage[]): Array<{
        role: "system" | "user" | "assistant" | "tool";
        content: string;
        tool_call_id?: string;
        tool_calls?: Array<{
            id: string;
            type: "function";
            function: {
                name: string;
                arguments: string;
            };
        }>;
    }>;
    toXenoMessages(apiMessages: ApiMessage[], options?: {
        allowImages?: boolean;
    }): XenoChatMessage[];
    private buildStructuredToolContextMessage;
    private modelSupportsImageInputs;
    private describeSuppressedImageBlock;
    getChatCompletionsBaseUrl(): string;
    private condenseToolResultForModel;
    buildXenoToolDefinitions(tools: ToolDefinition[]): Array<{
        type: "function";
        function: {
            name: string;
            description: string;
            parameters: ToolDefinition["input_schema"];
        };
    }>;
    private buildChatCompletionsRequestBody;
    private parseXenoCompletion;
    static parseRetryAfterSeconds(value: string | null): number | undefined;
    private static getHeaderValue;
    private static stripHtml;
    private static summarizeErrorBody;
    private authorizationHeaders;
    private createApiRequestSignal;
    callChatCompletionsNonStream(model: string, apiMessages: ApiMessage[], tools: ToolDefinition[], onText?: (text: string) => void, signal?: AbortSignal): Promise<StreamResult>;
    callChatCompletions(model: string, apiMessages: ApiMessage[], tools: ToolDefinition[], onText?: (text: string) => void, signal?: AbortSignal): Promise<StreamResult>;
    callOllama(model: string, apiMessages: ApiMessage[], tools: ToolDefinition[], onText?: (text: string) => void, signal?: AbortSignal): Promise<StreamResult>;
}
type LLMProviderMessage = ApiMessage;
type LLMCompletionResult = StreamResult;
type ProviderStreamEvent = {
    type: "message.started";
    providerMessageId?: string;
} | {
    type: "text.delta";
    text: string;
} | {
    type: "reasoning.delta";
    text: string;
} | {
    type: "tool_call.started";
    index: number;
    toolCallId: string;
    name: string;
} | {
    type: "tool_call.arguments.delta";
    index: number;
    toolCallId: string;
    delta: string;
} | {
    type: "tool_call.completed";
    index: number;
    toolCallId: string;
    name: string;
    input: Record<string, unknown>;
} | {
    type: "usage.updated";
    inputTokens: number;
    outputTokens: number;
} | {
    type: "provider.warning";
    code: string;
    message: string;
} | {
    type: "provider.retry";
    retryAfterMs?: number;
    reason: string;
} | {
    type: "message.completed";
    stopReason: LLMCompletionResult["stopReason"];
} | {
    type: "provider.error";
    code: string;
    category: string;
    retryable: boolean;
} | {
    type: "provider.cancelled";
};
interface LLMProviderRequestContext {
    systemPrompt: string;
    attemptId?: string;
    onEvent?: (event: ProviderStreamEvent) => void | Promise<void>;
}
interface LLMProviderCapabilities {
    readonly streaming?: boolean;
    readonly textInput?: boolean;
    readonly tools?: boolean;
    readonly parallelToolCalls?: boolean;
    readonly vision?: boolean;
    readonly imageInput?: boolean;
    readonly structuredOutput?: boolean;
    readonly reasoningMetadata?: boolean;
    readonly usageAccounting?: boolean;
    readonly cancellation?: boolean;
    readonly retryAfter?: boolean;
    readonly promptCaching?: boolean;
    readonly [capability: string]: boolean | undefined;
}
interface LLMProvider {
    prepareQuotaRequest?(model: string, messages: LLMProviderMessage[], tools: ToolDefinition[], context?: LLMProviderRequestContext, signal?: AbortSignal): Promise<{
        basis: "provider-enforced";
        inputTokensUpperBound: number;
        outputTokensUpperBound: number;
        execute(onText?: (text: string) => void, signal?: AbortSignal): Promise<LLMCompletionResult>;
    }>;
    readonly id: string;
    readonly model?: string;
    readonly capabilities?: LLMProviderCapabilities;
    complete(model: string, messages: LLMProviderMessage[], tools: ToolDefinition[], onText?: (text: string) => void, signal?: AbortSignal, context?: LLMProviderRequestContext): Promise<LLMCompletionResult>;
    completeLocal?(model: string, messages: LLMProviderMessage[], tools: ToolDefinition[], onText?: (text: string) => void, signal?: AbortSignal, context?: LLMProviderRequestContext): Promise<LLMCompletionResult>;
}
type QueryState = "idle" | "preparing" | "building_context" | "requesting_model" | "retrying" | "executing_tools" | "waiting_for_tool" | "evaluating_completion" | "finalizing" | "suspended" | "completed" | "failed" | "interrupted";
type QueryWatchdogReason = "idle" | "lease" | "hard";
type ToolOperationRuntimeEventType = "tool.operation.started" | "tool.operation.progress" | "tool.operation.promotion_requested" | "tool.operation.promoted" | "tool.operation.stalled" | "tool.operation.verifying" | "tool.operation.completed" | "tool.operation.failed" | "tool.operation.timed_out" | "tool.operation.cancelled";
type XenoRuntimeEventType = "thread.started" | "turn.started" | "turn.completed" | "turn.failed" | "turn.interrupted" | "query.state" | "query.watchdog" | "provider.event" | "model.text.delta" | "context.pressure" | "context.injected" | "context.history.compacted" | "tool.started" | "tool.permission" | "tool.completed" | "tool.history.repaired" | "tool.failure_guard.tripped" | ToolOperationRuntimeEventType | "turn.suspended" | "turn.continuation_enqueued" | "turn.continuation_resumed" | "turn.continuation_exhausted" | "diff.completed";
interface XenoRuntimeEventBase {
    id: string;
    sequence: number;
    type: XenoRuntimeEventType;
    timestamp: string;
    threadId?: string;
    turnId?: string;
}
type XenoRuntimeEvent = (XenoRuntimeEventBase & {
    type: "thread.started";
    cwd: string;
    model: string;
    effort?: string;
}) | (XenoRuntimeEventBase & {
    type: "turn.started";
    model: string;
    effort?: string;
    promptPreview: string;
    contextBudgetTokens?: number;
    contextBudgetSource?: "config" | "model" | "provider" | "fallback";
}) | (XenoRuntimeEventBase & {
    type: "turn.completed";
    outputPreview: string;
    tokenUsage: {
        input: number;
        output: number;
        total: number;
    };
    contextTokens?: number;
}) | (XenoRuntimeEventBase & {
    type: "context.pressure";
    turnId: string;
    iteration: number;
    contextTokens: number;
    budgetTokens: number;
    budgetSource: "config" | "model" | "provider" | "fallback";
}) | (XenoRuntimeEventBase & {
    type: "context.injected";
    messageId: string;
    sourceNodeId?: string;
    label?: string;
    deferred: boolean;
    turnId?: string;
    iteration?: number;
}) | (XenoRuntimeEventBase & {
    type: "context.history.compacted";
    turnId?: string;
    messagesRemoved: number;
    tokensSaved: number;
    beforeTokens: number;
    afterTokens: number;
    accounting: TokenAccountingSource;
    summaryMessageId: string;
    firstMessageId: string;
    lastMessageId: string;
    removedMessageIds: string[];
}) | (XenoRuntimeEventBase & {
    type: "turn.failed" | "turn.interrupted";
    error: string;
}) | (XenoRuntimeEventBase & {
    type: "query.state";
    from: QueryState;
    state: QueryState;
    iteration: number;
}) | (XenoRuntimeEventBase & {
    type: "query.watchdog";
    reason: QueryWatchdogReason;
    state: QueryState;
    iteration: number;
}) | (XenoRuntimeEventBase & {
    type: "provider.event";
    providerId: string;
    model: string;
    iteration: number;
    event: ProviderStreamEvent;
}) | (XenoRuntimeEventBase & {
    type: "model.text.delta";
    text: string;
    iteration?: number;
}) | (XenoRuntimeEventBase & {
    type: "tool.started";
    toolName: string;
    inputPreview: Record<string, unknown>;
    iteration?: number;
}) | (XenoRuntimeEventBase & {
    type: "tool.permission";
    toolName: string;
    allowed: boolean;
    reason: string;
    layer: "policy" | "sandbox" | "permission";
    iteration?: number;
}) | (XenoRuntimeEventBase & {
    type: "tool.completed";
    toolName: string;
    success: boolean;
    outputPreview: string;
    error?: string;
    webContext?: WebContextToolResult;
    elapsedMs: number;
    iteration?: number;
}) | (XenoRuntimeEventBase & {
    type: "tool.history.repaired";
    orphanedResultsRemoved: number;
    missingResultsInserted: number;
    orphanedResultIds: string[];
    missingResultIds: string[];
    idsTruncated: boolean;
}) | (XenoRuntimeEventBase & {
    type: "tool.failure_guard.tripped";
    toolName: string;
    category: ToolFailureCategory;
    reason: ToolFailureGuardTrip["reason"];
    attempts: number;
    errorFingerprint: string;
    targetFingerprint?: string;
    cycleLength?: number;
    iteration?: number;
}) | (XenoRuntimeEventBase & {
    type: ToolOperationRuntimeEventType;
    toolName: string;
    operation: ToolOperationSnapshot;
    progress?: ToolProgressUpdate;
}) | (XenoRuntimeEventBase & {
    type: "turn.suspended" | "turn.continuation_enqueued";
    continuationId: string;
    pendingOperationIds: string[];
    message: string;
}) | (XenoRuntimeEventBase & {
    type: "turn.continuation_resumed" | "turn.continuation_exhausted";
    continuationId: string;
    continuationTurns: number;
    message: string;
}) | (XenoRuntimeEventBase & {
    type: "diff.completed";
    filesChanged: number;
    summary: string;
});
type XenoRuntimeEventSink = (event: XenoRuntimeEvent) => void | Promise<void>;
type XenoRuntimeEventDraft = XenoRuntimeEvent extends infer Event ? Event extends XenoRuntimeEvent ? Omit<Event, "id" | "sequence" | "timestamp"> & Partial<Pick<XenoRuntimeEvent, "id" | "sequence" | "timestamp">> : never : never;
declare class XenoRuntimeEventBus {
    private readonly maxHistory;
    private listeners;
    private history;
    private sequence;
    constructor(maxHistory?: number);
    subscribe(listener: XenoRuntimeEventSink): () => void;
    nextSequence(): number;
    emit(event: XenoRuntimeEventDraft): void;
    snapshot(): XenoRuntimeEvent[];
}
type AuditRiskLevel = "none" | "low" | "medium" | "high" | "critical";
type AuditDecision = "allow" | "ask" | "deny";
type AuditStatus = "ok" | "error";
interface AuditEvent {
    id: string;
    sequence: number;
    timestamp: string;
    trace_id: string;
    session_id?: string;
    run_id?: string;
    agent_id?: string;
    parent_agent_id?: string;
    workspace?: string;
    model?: string;
    provider?: string;
    event_type: string;
    actor: "user" | "assistant" | "system";
    risk_level: AuditRiskLevel;
    tool_name?: string;
    decision?: AuditDecision;
    status?: AuditStatus;
    reason?: string;
    metadata?: Record<string, unknown>;
}
interface AuditLoggerOptions {
    filePath: string;
    sessionId?: string;
    runId?: string;
    agentId?: string;
    parentAgentId?: string;
    workspace?: string;
    model?: string;
    provider?: string;
}
declare class AuditLogger {
    private filePath;
    private sessionId?;
    private labels;
    private sequence;
    private writeQueue;
    constructor(options: AuditLoggerOptions);
    get path(): string;
    append(event: Omit<AuditEvent, "id" | "sequence" | "timestamp" | "session_id"> & {
        session_id?: string;
    }): Promise<string>;
    read(options?: {
        limit?: number;
        eventType?: string;
        traceId?: string;
    }): Promise<AuditEvent[]>;
    tail(limit?: number): Promise<AuditEvent[]>;
    exportJson(targetPath: string): Promise<number>;
    flush(): Promise<void>;
}
interface ToolContinuationGoal {
    sessionId: string;
    goalId: string;
    requestId: string;
}
interface TranscriptBytePageOptions {
    cursor?: string;
    maxBytes?: number;
    direction?: "forward" | "backward";
}
interface TranscriptBytePage {
    encoding: "base64";
    content: string;
    direction: "forward" | "backward";
    offset: number;
    bytesRead: number;
    totalBytes: number;
    transcriptVersion: string;
    nextCursor: string | null;
}
interface TranscriptRecordPageOptions {
    cursor?: string;
    maxBytes?: number;
    maxRecords?: number;
}
interface TranscriptPageRecord {
    offset: number;
    bytes: number;
    event: Readonly<Record<string, unknown>> & {
        id: string;
        timestamp: string;
        type: string;
        sequence: number;
    };
}
interface TranscriptRecordPage {
    cursor: string;
    records: TranscriptPageRecord[];
    issues: Array<{
        code: "invalid_record" | "record_exceeds_page_budget";
        offset: number;
        bytes: number;
    }>;
    bytesRead: number;
    totalBytes: number;
    transcriptVersion: string;
    nextCursor: string | null;
}
declare class TranscriptWriter {
    private sessionDir;
    private sessionId;
    private transcriptPath;
    private markdownPath;
    private workspaceMarkdownPath;
    private markdownHeaderWritten;
    private workspaceHeaderWritten;
    private workspaceMirrorDisabled;
    private sequence;
    private writeQueue;
    private pendingWrites;
    constructor(sessionDir: string);
    append(event: Omit<TranscriptEvent, "id" | "timestamp" | "sequence">): Promise<string>;
    private stringify;
    private formatMessageContent;
    private formatEventMarkdown;
    private ensureMarkdownHeader;
    private resolveWorkspaceMarkdownPath;
    private appendMarkdownEvent;
    private buildMarkdownDocument;
    readBytePage(options?: TranscriptBytePageOptions): Promise<TranscriptBytePage | null>;
    readRecordPage(options?: TranscriptRecordPageOptions): Promise<TranscriptRecordPage | null>;
    read(options?: {
        types?: TranscriptEventType[];
        limit?: number;
        offset?: number;
    }): Promise<TranscriptEvent[]>;
    private isMessageData;
    isMessageEvent(event: TranscriptEvent): event is TranscriptEvent & {
        data: Message;
    };
    readValidated(): Promise<{
        events: TranscriptEvent[];
        issues: Array<{
            code: "torn_transcript_tail" | "invalid_transcript_event" | "non_monotonic_sequence";
            detail: string;
        }>;
    }>;
    getMessages(): Promise<Message[]>;
    replaceMessages(messages: Message[]): Promise<void>;
    truncateAfterMessageCount(messageCount: number): Promise<void>;
    getSequence(): number;
    initialize(): Promise<void>;
    flush(): Promise<void>;
}
declare class CheckpointManager {
    private sessionDir;
    private checkpointsDir;
    private autoInterval;
    private lastCheckpointMessageCount;
    constructor(sessionDir: string, options?: {
        autoInterval?: number;
    });
    initialize(): Promise<void>;
    create(options: {
        trigger: CheckpointTrigger;
        messages: Message[];
        description?: string;
    }): Promise<CheckpointInfo>;
    list(): Promise<CheckpointInfo[]>;
    restore(checkpointId: string): Promise<{
        messages: Message[];
        info: CheckpointInfo;
    }>;
    shouldAutoCheckpoint(currentMessageCount: number): boolean;
    static isDangerousOperation(toolName: string, input: unknown): boolean;
    delete(checkpointId: string): Promise<void>;
    private estimateTokens;
}
interface SessionCreateOptions {
    role?: string;
    parentSession?: string;
    workingDirectory: string;
    model: string;
    executionMode?: ExecutionMode;
    hostBinding?: AgentSessionHostBindingV1;
}
interface SessionResumeOptions {
    sessionId: string;
    fromCheckpoint?: string;
}
type SessionRecoverySource = "transcript" | "checkpoint" | "empty";
interface SessionRecoveryIssue {
    code: "torn_transcript_tail" | "invalid_transcript_event" | "non_monotonic_sequence" | "interrupted_tool_call" | "checkpoint_fallback" | "divergent_checkpoint" | "stale_metadata" | "invalid_compaction_snapshot";
    detail: string;
}
interface SessionRecoveryResult {
    messages: Message[];
    transcriptMessages: Message[];
    source: SessionRecoverySource;
    sourceId?: string;
    issues: SessionRecoveryIssue[];
    repairMessages: Message[];
    transcriptEventCount: number;
    latestTimestamp?: string;
}
declare class SessionManager {
    private sessionDir;
    private _meta;
    private _transcript;
    private _checkpoints;
    private _lock;
    private _recovery;
    private _detachedForHandoff;
    private metadataWrites;
    private detachingForHandoff;
    private constructor();
    static create(options: SessionCreateOptions): Promise<SessionManager>;
    static resume(options: SessionResumeOptions): Promise<SessionManager>;
    get meta(): SessionMeta;
    get transcript(): TranscriptWriter;
    get checkpoints(): CheckpointManager;
    get recovery(): SessionRecoveryResult;
    detachForHandoff(): Promise<void>;
    get detachedForHandoff(): boolean;
    updateMeta(partial: Partial<SessionMeta>, options?: {
        requirePersistence?: boolean;
    }): Promise<void>;
    rename(name: string): Promise<SessionMeta>;
    private commitMeta;
    end(status?: "completed" | "abandoned"): Promise<void>;
    recordUserMessage(content: string): Promise<void>;
    recordDirectShellResult(record: DirectShellResultRecord): Promise<Message>;
    recordAssistantMessage(content: string | ContentBlock[] | ToolResultBlock[], tokenCount?: number): Promise<void>;
    recordTokenUsage(input: number, output: number): Promise<void>;
    recordDelegationSummary(data: DelegationSummaryData): Promise<void>;
    updateMessageCount(count: number): Promise<void>;
}
interface ToolMiddlewareContext {
    readonly toolName: string;
    readonly toolCallId: string;
    input: Record<string, unknown>;
    readonly iteration: number;
    readonly traceId: string;
    readonly signal: AbortSignal;
    addGuidance(text: string): void;
}
type ToolMiddleware = (ctx: ToolMiddlewareContext, next: () => Promise<ToolResult>) => Promise<ToolResult>;
interface PromptSectionContext {
    readonly systemPrompt: string;
    readonly taskPrompt?: string;
    readonly iteration: number;
    readonly model: string;
}
interface PromptSectionProvider {
    name: string;
    order?: number;
    provide(ctx: PromptSectionContext): string | null | undefined;
}
type CompletionGuardStopReason = "end_turn" | "tool_use" | "max_tokens" | "stop_sequence" | "empty_response" | "progress_checkpoint";
interface CompletionGuardTurnStats {
    readonly iteration: number;
    readonly maxIterations: number;
    readonly toolCalls: number;
    readonly toolFailures: number;
    readonly failuresByTool: Readonly<Record<string, number>>;
}
interface CompletionGuardEvaluationContext {
    readonly finalText: string;
    readonly iteration: number;
    readonly maxIterations: number;
    readonly messages: Message[];
    readonly stopReason: CompletionGuardStopReason;
    readonly stats: CompletionGuardTurnStats;
}
type CompletionGuardDecision = {
    allow: true;
} | {
    allow: false;
    guidance: string;
    stop?: boolean;
};
interface CompletionGuard {
    name: string;
    order?: number;
    evaluate(ctx: CompletionGuardEvaluationContext): CompletionGuardDecision | null | undefined | Promise<CompletionGuardDecision | null | undefined>;
}
type CompressionLLMFn = (systemPrompt: string, messages: Message[]) => Promise<string>;
interface ModelWorkRequestIdentity {
    requestId: string;
    turnId: string;
    iteration: number;
    model: string;
}
type ModelWorkSettlement = ModelWorkRequestIdentity & ({
    status: "metered";
    inputTokens: number;
    outputTokens: number;
} | {
    status: "unknown";
});
interface ModelWorkAccounting {
    admit(request: Readonly<ModelWorkRequestIdentity>, signal: AbortSignal): void | Promise<void>;
    settle(result: Readonly<ModelWorkSettlement>, signal: AbortSignal): void | Promise<void>;
}
interface ModeSwitchRequest {
    from: ExecutionMode;
    to: ExecutionMode;
    requestedTools: string[];
    reason: string;
}
interface AgentLoopConfig {
    apiKey?: string;
    authorizeRequest?(target: {
        method: string;
        url: string;
    }): Promise<{
        authorization: string;
        dpop?: string;
    } | null>;
    baseURL: string;
    ollamaBaseURL?: string;
    localRuntimeUrl?: string;
    localRuntimeProtocol?: "openai-chat" | "ollama-native";
    localTransportLimits?: ProviderTransportLimits;
    model: string;
    fallbackModels?: string[];
    effort?: AgentEffortLevel;
    maxTokens: number;
    maxIterations: number;
    reserveFinalSynthesisTurn?: boolean;
    systemPrompt: string;
    requesterLabel?: string;
    ownerSessionId?: string;
    getOwnerSessionId?: () => string | undefined;
    executionMode?: ExecutionMode;
    permissionEngine: PermissionEngine;
    toolRegistry?: ToolRegistry;
    onText?: (text: string) => void;
    onToolStart?: (name: string, input: Record<string, unknown>) => void;
    onToolWillExecute?: (name: string, input: Record<string, unknown>) => void | Promise<void>;
    onToolEnd?: (name: string, result: ToolResult) => void;
    onIteration?: (iteration: number, totalTokens: number) => void;
    modelWorkAccounting?: ModelWorkAccounting;
    onError?: (error: Error, context: string) => void;
    onTranscriptError?: (error: Error, context: string) => void;
    onModeSwitchRequest?: (request: ModeSwitchRequest) => Promise<boolean>;
    onExecutionModeChanged?: (mode: ExecutionMode, reason: string) => void;
    onContextCompressed?: (messagesRemoved: number, tokensSaved: number, record?: CompactionRecord) => void;
    onRuntimeEvent?: XenoRuntimeEventSink;
    runtimeEventBus?: XenoRuntimeEventBus;
    turnDiffTracker?: TurnDiffTracker;
    onTurnDiff?: (summary: TurnDiffSummary) => void | Promise<void>;
    completionGuard?: (context: CompletionGuardContext) => Promise<CompletionGuardResult | null> | CompletionGuardResult | null;
    maxCompletionGuardReminders?: number;
    progressGuardEveryIterations?: number;
    apiRequestTimeoutMs?: number;
    queryIdleTimeoutMs?: number;
    queryLeaseTimeoutMs?: number;
    queryHardTimeoutMs?: number;
    runStartedAtMs?: number;
    externalTimeoutMs?: number;
    apiDeadlineFinalBufferMs?: number;
    backgroundTaskDrainMaxWaitMs?: number;
    backgroundTaskDrainPollIntervalMs?: number;
    backgroundTaskDrainExtraIterations?: number;
    sandbox?: AgentSandbox;
    onPermissionRequest?: (context: PermissionRequestContext) => Promise<PermissionRequestResult> | PermissionRequestResult;
    toolMiddleware?: ToolMiddleware[];
    promptSections?: PromptSectionProvider[];
    promptSectionsTokenBudget?: number;
    completionGuards?: CompletionGuard[];
    provider?: LLMProvider;
    transcript?: TranscriptWriter;
    checkpoints?: CheckpointManager;
    sessionManager?: SessionManager;
    autoCheckpointInterval?: number;
    maxContextTokens?: number;
    maxContextMessages?: number;
    historyMarkdownPath?: string;
    compressionKeepRecentMessages?: number;
    contextCompressionLlm?: CompressionLLMFn;
    tokenEstimator?: TokenEstimator;
    tokenAccountingAdapter?: TokenAccountingAdapter;
    auditLogger?: AuditLogger;
}
interface CompletionGuardContext {
    finalText: string;
    iteration: number;
    messages: Message[];
    stopReason: StreamResult["stopReason"] | "empty_response" | "progress_checkpoint";
}
interface RunStreamOptions {
    signal?: AbortSignal;
}
interface CompletionGuardResultObject {
    message: string;
    blocking?: boolean;
    stop?: boolean;
    toolPolicy?: CompletionGuardToolPolicy;
}
type CompletionGuardResult = string | CompletionGuardResultObject;
type CompletionGuardToolPolicyMode = "require_output_checkpoint";
interface CompletionGuardToolPolicy {
    mode: CompletionGuardToolPolicyMode;
    requiredOutputPaths?: string[];
    message?: string;
}
type AgentRunTerminationStatus = "completed" | "incomplete" | "suspended" | "interrupted" | "error";
type AgentRunTerminationReason = "end_turn" | "empty_response" | "max_tokens" | "completion_guard_stop" | "max_iterations" | "awaiting_operation" | "continuation_exhausted" | "interrupted" | "watchdog_idle" | "watchdog_lease" | "watchdog_hard" | "error";
interface AgentRunTermination {
    status: AgentRunTerminationStatus;
    reason: AgentRunTerminationReason;
    iteration: number;
    maxIterations: number;
    finalStateVerified: boolean;
    message: string;
}
interface SessionIntegrationConfig {
    transcript?: TranscriptWriter;
    checkpoints?: CheckpointManager;
    sessionManager?: SessionManager;
    historyMarkdownPath?: string;
    auditLogger?: AuditLogger;
}
interface AgentRunOptions {
    messageId?: string;
    goalTurn?: ToolContinuationGoal;
    continuationId?: string;
}
declare class AgentLoop {
    private config;
    private toolRegistry;
    private _messages;
    private totalInputTokens;
    private modelWorkAttemptedRequests;
    private modelWorkMeteredRequests;
    private totalOutputTokens;
    private lastRequestInputTokens;
    private pendingContextInjections;
    private lastCheckpointMessageCount;
    private ollamaBaseUrl;
    private activeAbortController;
    private interruptionRequested;
    private currentTraceId;
    private lastRunTraceId;
    private currentOwnerSessionId;
    private lastRunTerminationInfo;
    private activeTaskPrompt;
    private activeToolPolicy;
    private apiFailureDiagnosticsLogged;
    private queryLifecycle;
    private toolWaitDepth;
    private watchdogReason;
    private readonly runtimeEventBus;
    private readonly threadId;
    private readonly turnDiffTracker?;
    private readonly llm;
    private readonly messageFlow;
    private readonly middleware;
    private readonly promptSections;
    private readonly completionGuards;
    private readonly toolFailureGuard;
    private turnToolCalls;
    private turnToolFailures;
    private turnFailuresByTool;
    private turnIteration;
    constructor(config: AgentLoopConfig);
    get tokenUsage(): {
        input: number;
        output: number;
        total: number;
    };
    get modelWorkUsage(): {
        attemptedRequests: number;
        meteredRequests: number;
        coverageComplete: boolean;
    };
    get lastTraceId(): string | null;
    get lastRunTermination(): AgentRunTermination | null;
    get queryState(): QueryState;
    get model(): string;
    set model(value: string);
    get effort(): AgentEffortLevel | undefined;
    set effort(value: AgentEffortLevel | undefined);
    get executionMode(): ExecutionMode;
    set executionMode(value: ExecutionMode);
    get systemPrompt(): string;
    set systemPrompt(value: string);
    use(middleware: ToolMiddleware): this;
    registerPromptSection(provider: PromptSectionProvider): this;
    registerCompletionGuard(guard: CompletionGuard): this;
    attachSessionIntegration(config: SessionIntegrationConfig): void;
    cancelCurrentTurn(): boolean;
    private emitRuntimeEvent;
    private finalizeTurnDiff;
    private handleTextDelta;
    private handleContextCompressed;
    private isAbortError;
    private isParallelSafeTool;
    private pathAliasesForToolPolicy;
    private toolPolicyMentionsRequiredPath;
    private toolPolicyTargetsRequiredPath;
    private bashCommandCanCreateRequiredOutput;
    private toolCallSatisfiesToolPolicy;
    private maybeBlockActiveToolPolicy;
    private getCompressedSourceSizeLimit;
    private isSourceLikePath;
    private isBinaryReimplementationContractTask;
    private getOriginalBinaryAliases;
    private textMentionsOriginalBinary;
    private sourceContainsOriginalBinaryBypass;
    private sourceGenerationCommandContainsOriginalBinaryBypass;
    private buildSourceIndependenceBlock;
    private maybeBlockSourceIndependenceViolation;
    private maybeBlockKnownInvalidWrite;
    private maybeBlockKnownInvalidBashSourceGeneration;
    private recordToolEventsToTranscript;
    protected callChatCompletions(model: string, apiMessages: ApiMessage[], tools: ToolDefinition[], onText?: (text: string) => void, signal?: AbortSignal): Promise<StreamResult>;
    protected callOllama(model: string, apiMessages: ApiMessage[], tools: ToolDefinition[], onText?: (text: string) => void, signal?: AbortSignal): Promise<StreamResult>;
    protected toXenoMessages(apiMessages: ApiMessage[]): ReturnType<LlmClient["toXenoMessages"]>;
    protected toOllamaMessages(apiMessages: ApiMessage[]): ReturnType<LlmClient["toOllamaMessages"]>;
    private executeToolCall;
    private isContextOverflowError;
    private maybeBlockRepeatedToolFailure;
    private recordTurnToolStats;
    private currentTurnStats;
    private appendAuditEvent;
    private setExecutionModeInternal;
    private maybeAppendApiRequestFailureAudit;
    private static parsePositiveInteger;
    private sleep;
    private getApiDeadlineFinalBufferMs;
    private getExternalDeadlineMs;
    private getBackgroundTaskDrainMaxWaitMs;
    private getBackgroundTaskDrainPollIntervalMs;
    private getBackgroundTaskDrainExtraIterations;
    private getBackgroundTaskDrainBudgetMs;
    private getDrainableBackgroundTasks;
    private summarizeBackgroundTaskSnapshot;
    private maybeDrainBackgroundTasksAtIterationBudget;
    private getApiRequestTimeoutMs;
    private resolveContextBudget;
    private getModelContextLimit;
    private createApiRequestSignal;
    private buildRuntimeSystemPrompt;
    private unresolvedToolUseIds;
    injectContext(input: {
        content: string;
        sourceNodeId?: string;
        label?: string;
    }): Promise<{
        status: "injected" | "deferred";
        pendingCount: number;
    }>;
    get pendingContextInjectionCount(): number;
    private flushContextInjections;
    get messages(): Message[];
    set messages(value: Message[]);
    private shouldAutoCheckpoint;
    private getApiMessagesForRequest;
    private appendSyntheticUserMessage;
    private appendSyntheticAssistantMessage;
    private projectAssistantContentForPersistence;
    run(userMessage: string, options?: AgentRunOptions): Promise<string>;
    runStream(prompt: string, options?: RunStreamOptions): AsyncIterable<XenoRuntimeEvent>;
    private createRuntimeEventIterator;
    private runInternal;
    clearHistory(): void;
}
type AppType = "pixel" | "motion" | "sound";
interface DocumentContext {
    name: string;
    path?: string;
    modified: boolean;
}
interface LayerContext {
    id: string;
    name: string;
    type: string;
}
interface ClipContext {
    id: string;
    name: string;
    type: string;
}
interface TrackContext {
    id: string;
    name: string;
}
interface CanvasSize {
    width: number;
    height: number;
}
interface AppContext {
    app: AppType;
    document?: DocumentContext;
    activeLayer?: LayerContext;
    selectedTool?: string;
    canvasSize?: CanvasSize;
    currentFrame?: number;
    selectedClip?: ClipContext;
    timelineLength?: number;
    bpm?: number;
    currentPosition?: number;
    selectedTrack?: TrackContext;
    isRecording?: boolean;
}
type AppContextProvider = () => AppContext;
declare class AppContextManager {
    private provider;
    setProvider(provider: AppContextProvider): void;
    getContext(): AppContext;
    formatForPrompt(): string;
}
interface PermissionInfo {
    toolName: string;
    input: unknown;
    riskLevel: "low" | "medium" | "high";
}
interface AgentStreamCallbacks {
    onText: (text: string) => void;
    onToolStart: (name: string, input: unknown) => void;
    onToolEnd: (name: string, result: unknown) => void;
    onComplete: () => void;
    onError: (error: Error) => void;
}
interface ElectronAgentConfig {
    apiKey: string;
    baseURL: string;
    model: string;
    app: AppType;
    tools: RegisteredTool[];
    appContext: () => AppContext;
    onPermissionRequest?: (info: PermissionInfo) => Promise<"allow" | "deny">;
    maxTokens?: number;
    maxIterations?: number;
}
declare class ElectronAgentBridge {
    private agent;
    private readonly contextManager;
    private readonly config;
    private readonly toolRegistry;
    private readonly permissionEngine;
    private pendingPermissions;
    constructor(config: ElectronAgentConfig);
    private buildSystemPrompt;
    sendMessage(text: string, callbacks: AgentStreamCallbacks): Promise<void>;
    cancel(): boolean;
    getHistory(): Message[];
    clearHistory(): void;
    updateContext(): void;
    respondToPermission(id: string, decision: "allow" | "deny"): void;
    getAgentLoop(): AgentLoop;
    getContextManager(): AppContextManager;
    getToolRegistry(): ToolRegistry;
}
interface PermissionRequestInfo {
    id: string;
    toolName: string;
    input: unknown;
    riskLevel: "low" | "medium" | "high";
    description?: string;
}
interface AgentToAppMessages {
    "agent:text": {
        text: string;
    };
    "agent:tool-start": {
        name: string;
        input: unknown;
    };
    "agent:tool-end": {
        name: string;
        result: unknown;
        success: boolean;
    };
    "agent:complete": Record<string, never>;
    "agent:error": {
        message: string;
        code?: string;
    };
    "agent:permission-request": PermissionRequestInfo;
}
interface AppToAgentMessages {
    "agent:send-message": {
        text: string;
    };
    "agent:cancel": Record<string, never>;
    "agent:clear": Record<string, never>;
    "agent:permission-response": {
        id: string;
        decision: "allow" | "deny";
    };
}
type AgentToAppChannel = keyof AgentToAppMessages;
type AppToAgentChannel = keyof AppToAgentMessages;
type AgentIpcChannel = AgentToAppChannel | AppToAgentChannel;
type IpcHandler<C extends string, M extends Record<string, unknown>> = C extends keyof M ? (payload: M[C]) => void : never;
type DualLLMMode = "auto" | "local" | "cloud";
interface ChatParams {
    messages: Array<{
        role: "system" | "user" | "assistant";
        content: string;
    }>;
    model?: string;
    maxTokens?: number;
    temperature?: number;
    systemPrompt?: string;
    jsonMode?: boolean;
    stop?: string[];
}
interface ChatResponse {
    success: boolean;
    content: string;
    endpoint: "local" | "cloud";
    model: string;
    usage: {
        promptTokens: number;
        completionTokens: number;
        totalTokens: number;
    };
    error?: string;
}
interface DualLLMStatus {
    mode: DualLLMMode;
    localAvailable: boolean;
    activeEndpoint: "local" | "cloud";
    localModel?: string;
    localUrl: string;
    cloudUrl: string;
}
interface DualLLMProviderConfig {
    localUrl?: string;
    cloudUrl?: string;
    cloudApiKey?: string;
    mode?: DualLLMMode;
    localModel?: string;
    cloudModel?: string;
}
declare class DualLLMProvider {
    private localUrl;
    private cloudUrl;
    private cloudApiKey;
    private mode;
    private defaultLocalModel;
    private defaultCloudModel;
    private localAvailable;
    private localModelName;
    private lastHealthCheck;
    constructor(config?: DualLLMProviderConfig);
    chat(params: ChatParams): Promise<ChatResponse>;
    chatStream(params: ChatParams): AsyncGenerator<string>;
    isLocalAvailable(forceRefresh?: boolean): Promise<boolean>;
    setMode(mode: DualLLMMode): void;
    getMode(): DualLLMMode;
    setLocalUrl(url: string): void;
    setCloudApiKey(apiKey: string): void;
    getStatus(): Promise<DualLLMStatus>;
    asLLMProvider(options?: {
        id?: string;
        model?: string;
    }): LLMProvider;
    private shouldUseLocal;
    private chatLocal;
    private chatCloud;
}
type IpcHandleFunction = (channel: string, handler: (event: unknown, ...args: unknown[]) => unknown) => void;
interface SetupAIHandlersOptions {
    ipcHandle: IpcHandleFunction;
    config?: DualLLMProviderConfig;
    provider?: DualLLMProvider;
}
declare function setupAIHandlers(options: SetupAIHandlersOptions): DualLLMProvider;
declare function readXenoApiKey(): string | undefined;
export { type AgentIpcChannel, type AgentStreamCallbacks, type AgentToAppChannel, type AgentToAppMessages, type AppToAgentChannel, type AppToAgentMessages, ElectronAgentBridge, type ElectronAgentConfig, type IpcHandler, type PermissionInfo, type PermissionRequestInfo, type SetupAIHandlersOptions, readXenoApiKey, setupAIHandlers };