import { type DrizzleExecutor } from "../drizzle.js";
import type { Duplex } from "node:stream";
import type { ModelCatalog, RemoteTerminalSummary } from "@slopus/rig/types";
import { type AgentSecretSummary, type MutationHint, type UserSummary } from "../chat/types.js";
import { type PubSub } from "../realtime/index.js";
import { RigDaemonClient } from "./daemon.js";
import type { AgentSandboxRuntimeResolver } from "../sandbox/types.js";
import type { PluginFunctionDefinition, PluginFunctionResult, PluginCallContext, PluginSkillDefinition } from "../plugin/types.js";
import type { PortShareContainerPort } from "../port-share/types.js";
import type { FileStorage } from "../files/storage.js";
interface AgentSecretCreateInput {
    actorUserId: string;
    description: string;
    environment: Record<string, string>;
    id: string;
}
interface AgentSecretTargetInput {
    actorUserId: string;
    secretId: string;
}
interface AgentSecretAgentInput extends AgentSecretTargetInput {
    agentUserId: string;
}
interface AgentSecretChannelInput extends AgentSecretTargetInput {
    channelId: string;
}
interface AgentPluginCapabilities {
    callFunction(functionName: string, args: unknown, context: PluginCallContext, signal?: AbortSignal): Promise<PluginFunctionResult>;
    listFunctions(signal?: AbortSignal): Promise<readonly PluginFunctionDefinition[]>;
    listSkills(signal?: AbortSignal): Promise<readonly PluginSkillDefinition[]>;
    readSkill(skill: PluginSkillDefinition, signal?: AbortSignal): Promise<PluginFunctionResult>;
}
export declare class AgentService {
    private readonly executor;
    private readonly pubsub;
    private readonly daemon;
    private readonly sandboxRuntime;
    private readonly defaultCwd;
    private readonly fileStorage;
    private readonly pluginCapabilities;
    private readonly onError;
    private readonly workerId;
    private readonly bindingCreations;
    private readonly imageBuilds;
    private readonly imageBuildRetries;
    private readonly imageMutations;
    private readonly pendingImageBuilds;
    private readonly agentConfigurationMutations;
    private readonly secretMutations;
    private readonly portShareTargets;
    private readonly containerConfigurations;
    private readonly containerReplacements;
    private activeImageBuilds;
    private readonly drains;
    private readonly turnStreams;
    private readonly typingRenewals;
    private readonly agentActivities;
    private readonly shutdown;
    private queueTask?;
    private stopping;
    constructor(executor: DrizzleExecutor, pubsub: PubSub, daemon: RigDaemonClient, sandboxRuntime: AgentSandboxRuntimeResolver, defaultCwd: string, fileStorage: FileStorage, pluginCapabilities: AgentPluginCapabilities | undefined, onError?: (error: unknown) => void);
    resolvePortShareTarget(input: {
        agentUserId: string;
        chatId: string;
        containerName: string;
        containerPort: PortShareContainerPort;
    }): Promise<{
        host: "127.0.0.1";
        port: number;
    }>;
    private resolveUncachedPortShareTarget;
    private ensureContainerConfiguration;
    private currentContainerName;
    private reconcileContainerConfiguration;
    private removeSandbox;
    createAgent(input: {
        actorUserId: string;
        name: string;
        username: string;
    }): Promise<{
        chat: import("../chat/types.js").ChatSummary;
        hint: MutationHint;
    }>;
    createAgentConversation(input: {
        actorUserId: string;
        agentUserId: string;
    }): Promise<{
        chat: import("../chat/types.js").ChatSummary;
        hint: MutationHint;
    }>;
    modelCatalog(): Promise<ModelCatalog>;
    modelRequireAvailable(modelId: string): Promise<void>;
    changeChatModel(input: {
        actorUserId: string;
        chatId: string;
        modelId: string;
    }): Promise<{
        chat: import("../chat/types.js").ChatSummary;
        sync?: MutationHint | undefined;
    }>;
    start(): Promise<void>;
    prepareTurns(input: {
        actorUserId: string;
        agentUserIds: readonly string[];
        chatId: string;
    }): Promise<Array<{
        agentUserId: string;
        sessionId: string;
    }>>;
    createTerminal(input: {
        actorUserId: string;
        agentUserId: string;
        chatId: string;
        cols: number;
        rows: number;
    }): Promise<{
        terminal: RemoteTerminalSummary;
    }>;
    attachTerminal(input: {
        actorUserId: string;
        agentUserId: string;
        chatId: string;
        terminalId: string;
    }): Promise<Duplex>;
    stopTerminal(input: {
        actorUserId: string;
        agentUserId: string;
        chatId: string;
        terminalId: string;
    }): Promise<{
        terminal: RemoteTerminalSummary;
    }>;
    /**
     * Stops the agent's in-flight run in this chat for a reader who can see it.
     * The durable stop lands first, so the worker still streaming the turn loses
     * its lease and unwinds even when it lives in another server instance; Rig is
     * then told to end the run so the model stops producing tokens.
     */
    stopRun(input: {
        actorUserId: string;
        agentUserId: string;
        chatId: string;
    }): Promise<{
        stopped: boolean;
    }>;
    private authorizedAgentSession;
    startTurn(chatId: string): void;
    /**
     * Hands every queued message for an already-running agent to Rig as steering
     * for the run in flight. Each delivery is claimed durably before the request
     * and confirmed only after Rig accepts it; a refusal releases the claim so
     * the message runs normally once the current turn ends.
     */
    private deliverSteering;
    getAgentEffort(input: {
        actorUserId: string;
        agentUserId: string;
        chatId: string;
    }): Promise<{
        agentUserId: string;
        effort: string;
        options: string[];
    }>;
    changeAgentEffort(input: {
        actorUserId: string;
        agentUserId: string;
        chatId: string;
        effort: string;
    }): Promise<{
        agentUserId: string;
        effort: string;
        options: string[];
        sync?: MutationHint | undefined;
    }>;
    listAgentImages(actorUserId: string): Promise<{
        defaultImageId?: string;
        images: import("../chat/types.js").AgentImageSummary[];
    }>;
    getAgentImage(actorUserId: string, imageId: string): Promise<import("../chat/types.js").AgentImageDetails>;
    listAgentImagesForHost(): Promise<{
        defaultEnvironmentId?: string;
        environments: import("../agent/agentImageListForHost.js").AgentEnvironmentHostSummary[];
    }>;
    getAgentImageDockerfileForHost(imageId: string): Promise<{
        id: string;
        name: string;
        dockerfile: string;
        active: boolean;
    }>;
    createAgentImage(input: {
        actorInstallationId?: string;
        actorUserId?: string;
        dockerfile: string;
        name: string;
    }): Promise<import("../chat/types.js").AgentImageSummary>;
    requestAgentImageBuild(input: {
        actorUserId: string;
        imageId: string;
    }): Promise<import("../chat/types.js").AgentImageSummary>;
    setDefaultAgentImage(input: {
        actorInstallationId?: string;
        actorUserId?: string;
        imageId: string;
    }): Promise<import("../chat/types.js").AgentImageSummary>;
    deactivateAgentImage(input: {
        actorInstallationId?: string;
        actorUserId?: string;
        imageId: string;
    }): Promise<{
        imageId: string;
    }>;
    getSetupBaseImages(actorUserId: string): Promise<{
        defaultImageId?: string;
        images: import("../setup/impl/baseImagePresentation.js").SetupBaseImageSummary[];
        selectedImage?: import("../setup/impl/baseImagePresentation.js").SetupBaseImageDetails;
        selectedImageId?: string;
    }>;
    selectSetupBaseImage(input: {
        actorUserId: string;
        selection: {
            builtinKey: "daycare-full" | "daycare-minimal";
            kind: "builtin";
        } | {
            dockerfile: string;
            kind: "custom";
            name: string;
        };
    }): Promise<{
        hint?: MutationHint;
        imageId: string;
        queueBuild: boolean;
    }>;
    retrySetupBaseImage(actorUserId: string): Promise<{
        hint: MutationHint;
        imageId: string;
    }>;
    changeAgentImage(input: {
        actorUserId: string;
        agentUserId: string;
        imageId: string;
    }): Promise<{
        user: UserSummary;
        sync?: MutationHint;
    }>;
    private changeAgentImageMutation;
    listAgentSecrets(actorUserId: string): Promise<{
        secrets: AgentSecretSummary[];
    }>;
    createAgentSecret(input: AgentSecretCreateInput): Promise<{
        secret: AgentSecretSummary;
        sync: MutationHint;
    }>;
    private createAgentSecretMutation;
    deleteAgentSecret(input: AgentSecretTargetInput): Promise<{
        removed: boolean;
        sync: MutationHint;
    }>;
    private deleteAgentSecretMutation;
    attachAgentSecretToAgent(input: AgentSecretAgentInput): Promise<{
        secret: AgentSecretSummary;
        sync?: MutationHint;
    }>;
    private attachAgentSecretToAgentMutation;
    detachAgentSecretFromAgent(input: AgentSecretAgentInput): Promise<{
        secret: AgentSecretSummary;
        sync?: MutationHint;
    }>;
    private detachAgentSecretFromAgentMutation;
    attachAgentSecretToChannel(input: AgentSecretChannelInput): Promise<{
        secret: AgentSecretSummary;
        sync?: MutationHint;
    }>;
    private attachAgentSecretToChannelMutation;
    detachAgentSecretFromChannel(input: AgentSecretChannelInput): Promise<{
        secret: AgentSecretSummary;
        sync?: MutationHint;
    }>;
    private detachAgentSecretFromChannelMutation;
    private serializeAgentConfiguration;
    private serializeAgentSecret;
    private ensureAgentBinding;
    close(): Promise<void>;
    private queueImageBuild;
    private drainImageBuildQueue;
    private buildImage;
    private scheduleImageBuildRetry;
    private publishAgentImageHint;
    private publishAgentHint;
    private agentEffortConfiguration;
    private reconcileAgentEfforts;
    private reconcileFunctionPermissions;
    private reconcileSessionEffort;
    private requireAgentSecret;
    private agentSecret;
    private reconcileSecretBindings;
    private trackGlobalEvents;
    private trimGlobalEventsIfDue;
    private applyGlobalEvent;
    private executePluginFunctionCall;
    private executePluginSkillRead;
    private executeDurablePluginCall;
    private startDrain;
    private drainChat;
    private ensureTurnSubmitted;
    private materializeTurnAttachments;
    private startTurnStream;
    private consumeTurnStream;
    /**
     * Publishes the notice that the running turn took the steering messages Rig
     * names. Rig identifies them by the ids Happy submitted, so each one maps
     * straight back to the message someone sent; the notice lands in the chat at
     * the moment it was applied rather than moving the original message.
     */
    private applySteering;
    private stopTurnStream;
    private publishAgentReplyHint;
    private retryRig;
    private completeTurn;
    private failTurn;
    private startAgentActivity;
    private updateAgentActivity;
    private stopAgentActivity;
    private clearAgentActivity;
    private publishAgentActivity;
    private startTyping;
    private stopTyping;
    private clearTypingRenewal;
    private publishTyping;
}
export {};
//# sourceMappingURL=service.d.ts.map