@otto-code/server 0.5.0

package/dist/server/server/agent/create-agent/create.js

@@ -0,0 +1,370 @@
+import { PARENT_AGENT_ID_LABEL } from "@otto-code/protocol/agent-labels";
+import { expandUserPath, resolvePathFromBase } from "../../path-utils.js";
+import { toWorktreeRequestError } from "../../worktree-errors.js";
+import { setupFinishNotification, startCreatedAgentInitialPrompt } from "../agent-prompt.js";
+import { resolveCreateAgentTitles } from "../create-agent-title.js";
+import { normalizeClientMessageId, resolveClientMessageId } from "../../client-message-id.js";
+import { resolveRequiredProviderModel } from "../mcp-shared.js";
+import { appendTimelineItemIfAgentKnown, emitLiveTimelineItemIfAgentKnown, } from "../timeline-append.js";
+function requireResolvedWorkspaceId(workspaceId) {
+    if (!workspaceId) {
+        throw new Error("createAgentCommand requires a resolved workspaceId");
+    }
+    return workspaceId;
+}
+export function formatProviderModel(provider, model) {
+    if (!model || provider.includes("/")) {
+        return provider;
+    }
+    return `${provider}/${model}`;
+}
+function resolveProviderModel(providerValue) {
+    const providerInput = providerValue.trim();
+    if (providerInput.includes("/")) {
+        return resolveRequiredProviderModel(providerInput);
+    }
+    if (!providerInput) {
+        throw new Error("provider is required");
+    }
+    return { provider: providerInput, model: undefined };
+}
+export async function createAgentCommand(dependencies, input) {
+    const resolved = input.kind === "session"
+        ? await resolveSessionCreateAgent(dependencies, input)
+        : await resolveMcpCreateAgent(dependencies, input);
+    const snapshot = await dependencies.agentManager.createAgent(resolved.config, undefined, resolved.createOptions);
+    resolved.setupContinuation?.startAfterAgentCreate({
+        agentId: snapshot.id,
+    });
+    let liveSnapshot = snapshot;
+    let initialPromptStarted = false;
+    let initialPromptError = null;
+    if (resolved.prompt !== undefined) {
+        const sendResult = await sendInitialPrompt(dependencies, resolved, snapshot);
+        initialPromptStarted = sendResult.started;
+        liveSnapshot = sendResult.liveSnapshot;
+        initialPromptError = sendResult.error ?? null;
+    }
+    if (input.kind === "mcp" && input.notifyOnFinish && input.callerAgentId && initialPromptStarted) {
+        setupFinishNotification({
+            agentManager: dependencies.agentManager,
+            agentStorage: dependencies.agentStorage,
+            childAgentId: snapshot.id,
+            callerAgentId: input.callerAgentId,
+            logger: dependencies.logger,
+        });
+    }
+    return {
+        snapshot,
+        liveSnapshot,
+        background: resolved.background,
+        initialPromptStarted,
+        initialPromptError,
+    };
+}
+async function resolveSessionCreateAgent(dependencies, input) {
+    const trimmedPrompt = input.initialPrompt?.trim();
+    const { sessionConfig, setupContinuation, createdWorkspaceId } = await input.buildSessionConfig(input.config, input.git, input.worktreeName, input.firstAgentContext);
+    const prompt = buildAgentPrompt(trimmedPrompt ?? "", input.images, input.attachments);
+    const hasPromptContent = Array.isArray(prompt) ? prompt.length > 0 : prompt.length > 0;
+    const clientMessageId = normalizeClientMessageId(input.clientMessageId);
+    const runOptions = input.outputSchema || clientMessageId
+        ? {
+            ...(input.outputSchema ? { outputSchema: input.outputSchema } : {}),
+            ...(clientMessageId ? { messageId: clientMessageId } : {}),
+        }
+        : undefined;
+    const workspaceId = setupContinuation ? createdWorkspaceId : input.workspaceId;
+    return {
+        config: sessionConfig,
+        createOptions: {
+            labels: input.labels,
+            initialPrompt: trimmedPrompt,
+            env: input.env,
+            initialTitle: input.provisionalTitle,
+            // A legacy git/worktreeName worktree creates a fresh workspace, so the
+            // agent belongs to that workspace, not the source one. createdWorkspaceId
+            // is the freshly created worktree's workspace.
+            workspaceId: requireResolvedWorkspaceId(workspaceId),
+        },
+        prompt: hasPromptContent ? prompt : undefined,
+        runOptions,
+        setupContinuation,
+        background: true,
+        promptFailure: "throw",
+        promptLogger: dependencies.logger.child({
+            clientMessageId: resolveClientMessageId(input.clientMessageId),
+        }),
+    };
+}
+async function resolveMcpCreateAgent(dependencies, input) {
+    const resolvedProviderModel = resolveProviderModel(input.provider);
+    const provider = resolvedProviderModel.provider;
+    const parentAgent = input.callerAgentId
+        ? requireParentAgent(dependencies.agentManager, input.callerAgentId)
+        : null;
+    const cwd = resolveMcpInitialCwd(input, parentAgent);
+    const { resolvedCwd, setupContinuation, createdWorkspaceId } = await resolveMcpCwd({
+        dependencies,
+        cwd,
+        worktree: input.worktree,
+        initialPrompt: input.initialPrompt ?? "",
+    });
+    const workspaceId = await resolveMcpWorkspaceId({
+        dependencies,
+        input,
+        parentAgent,
+        setupContinuation,
+        createdWorkspaceId,
+        resolvedCwd,
+    });
+    const resolvedCreateConfig = await resolveMcpProviderCreateConfig({
+        dependencies,
+        input,
+        provider,
+        resolvedCwd,
+        parentAgent,
+    });
+    const labels = mergeLabels({
+        callerAgentId: input.callerAgentId,
+        detached: input.detached ?? false,
+        childAgentDefaultLabels: input.callerContext?.childAgentDefaultLabels,
+        labels: input.labels,
+    });
+    const trimmedPrompt = input.initialPrompt?.trim() ?? "";
+    return {
+        config: buildMcpSessionConfig({
+            input,
+            resolvedProviderModel,
+            provider,
+            resolvedCwd,
+            trimmedPrompt,
+            resolvedMode: resolvedCreateConfig.modeId,
+            resolvedFeatures: resolvedCreateConfig.featureValues,
+        }),
+        createOptions: {
+            ...(labels ? { labels } : {}),
+            workspaceId: requireResolvedWorkspaceId(workspaceId),
+        },
+        prompt: trimmedPrompt ? trimmedPrompt : undefined,
+        setupContinuation,
+        background: input.background,
+        promptFailure: input.promptFailure ?? "log",
+    };
+}
+function resolveMcpInitialCwd(input, parentAgent) {
+    if (!parentAgent) {
+        return expandUserPath(input.cwd ?? process.cwd());
+    }
+    return resolveChildAgentCwd({
+        parentCwd: parentAgent.cwd,
+        requestedCwd: input.cwd,
+        lockedCwd: input.callerContext?.lockedCwd,
+        allowCustomCwd: input.callerContext?.allowCustomCwd ?? true,
+    });
+}
+async function resolveMcpWorkspaceId(params) {
+    // MCP callers resolve workspace ownership before this point. Worktree
+    // creation wins because the new agent lives in the fresh worktree workspace.
+    // Otherwise use the explicit workspace id, then the parent workspace for
+    // direct internal callers. Ownership is never resolved from cwd.
+    if (params.setupContinuation) {
+        return params.createdWorkspaceId;
+    }
+    if (params.input.workspaceId) {
+        return params.input.workspaceId;
+    }
+    if (params.parentAgent?.workspaceId) {
+        return params.parentAgent.workspaceId;
+    }
+    return ensureWorkspaceForMcpCreate(params.dependencies, params.resolvedCwd, params.input.initialPrompt ?? "");
+}
+async function resolveMcpProviderCreateConfig(params) {
+    const passthroughConfig = params.input.config;
+    return params.dependencies.providerSnapshotManager.resolveCreateConfig({
+        cwd: params.resolvedCwd,
+        provider: params.provider,
+        requestedMode: params.input.mode ?? passthroughConfig?.modeId,
+        featureValues: params.input.features ?? passthroughConfig?.featureValues,
+        parent: params.parentAgent,
+        unattended: params.input.unattended ?? false,
+    });
+}
+function buildMcpSessionConfig(params) {
+    const passthroughConfig = params.input.config;
+    const { provisionalTitle } = resolveCreateAgentTitles({
+        configTitle: passthroughConfig?.title ?? params.input.title,
+        initialPrompt: params.trimmedPrompt,
+    });
+    const featureValues = params.resolvedFeatures ?? passthroughConfig?.featureValues;
+    const config = {
+        ...passthroughConfig,
+        provider: params.provider,
+        cwd: params.resolvedCwd,
+        modeId: params.resolvedMode ?? passthroughConfig?.modeId,
+        model: params.resolvedProviderModel.model ?? passthroughConfig?.model,
+        thinkingOptionId: params.input.thinking ?? passthroughConfig?.thinkingOptionId,
+        internal: params.input.internal ?? passthroughConfig?.internal,
+    };
+    if (provisionalTitle) {
+        config.title = provisionalTitle;
+    }
+    if (featureValues) {
+        config.featureValues = featureValues;
+    }
+    return config;
+}
+async function ensureWorkspaceForMcpCreate(dependencies, cwd, initialPrompt) {
+    if (!dependencies.ensureWorkspaceForCreate) {
+        return undefined;
+    }
+    return dependencies.ensureWorkspaceForCreate(cwd, { prompt: initialPrompt });
+}
+async function sendInitialPrompt(dependencies, resolved, snapshot) {
+    try {
+        const prompt = resolved.prompt;
+        if (prompt === undefined) {
+            return { started: false, liveSnapshot: snapshot };
+        }
+        const liveSnapshot = await startCreatedAgentInitialPrompt({
+            agentManager: dependencies.agentManager,
+            agentId: snapshot.id,
+            snapshot,
+            prompt,
+            runOptions: resolved.runOptions,
+            logger: resolved.promptLogger ?? dependencies.logger,
+        });
+        return { started: true, liveSnapshot };
+    }
+    catch (error) {
+        if (resolved.promptFailure === "throw") {
+            throw error;
+        }
+        if (resolved.promptFailure === "return-error") {
+            return { started: false, liveSnapshot: snapshot, error };
+        }
+        dependencies.logger.error({ err: error, agentId: snapshot.id }, "Failed to run initial prompt");
+        return { started: false, liveSnapshot: snapshot };
+    }
+}
+function buildAgentPrompt(text, images, attachments) {
+    const normalized = text.trim();
+    const hasImages = (images?.length ?? 0) > 0;
+    const hasAttachments = (attachments?.length ?? 0) > 0;
+    if (!hasImages && !hasAttachments) {
+        return normalized;
+    }
+    const blocks = [];
+    if (normalized.length > 0) {
+        blocks.push({ type: "text", text: normalized });
+    }
+    for (const image of images ?? []) {
+        blocks.push({ type: "image", data: image.data, mimeType: image.mimeType });
+    }
+    for (const attachment of attachments ?? []) {
+        blocks.push(attachment);
+    }
+    return blocks;
+}
+function requireParentAgent(agentManager, parentAgentId) {
+    const parentAgent = agentManager.getAgent(parentAgentId);
+    if (!parentAgent) {
+        throw new Error(`Parent agent ${parentAgentId} not found`);
+    }
+    return parentAgent;
+}
+function resolveChildAgentCwd(params) {
+    const lockedCwd = params.lockedCwd?.trim();
+    if (lockedCwd) {
+        return expandUserPath(lockedCwd);
+    }
+    const requestedCwd = params.requestedCwd?.trim();
+    if (!requestedCwd || !params.allowCustomCwd) {
+        return params.parentCwd;
+    }
+    return resolvePathFromBase(params.parentCwd, requestedCwd);
+}
+async function resolveMcpCwd(params) {
+    const { dependencies, worktree } = params;
+    if (!worktree) {
+        return { resolvedCwd: params.cwd };
+    }
+    const shouldCreateWorktree = Boolean(worktree.worktreeName || worktree.refName || worktree.action || worktree.githubPrNumber);
+    if (!shouldCreateWorktree) {
+        return { resolvedCwd: params.cwd };
+    }
+    if (worktree.worktreeName &&
+        !worktree.baseBranch &&
+        !worktree.refName &&
+        !worktree.action &&
+        worktree.githubPrNumber === undefined) {
+        throw new Error("baseBranch is required when creating a worktree");
+    }
+    const baseBranch = worktree.baseBranch;
+    const createdWorktree = await createMcpWorktree({
+        input: {
+            cwd: params.cwd,
+            worktreeSlug: worktree.worktreeName,
+            branchName: worktree.branchName,
+            refName: worktree.refName,
+            action: worktree.action,
+            githubPrNumber: worktree.githubPrNumber,
+            firstAgentContext: { prompt: params.initialPrompt },
+            runSetup: false,
+            ottoHome: dependencies.ottoHome,
+            worktreesRoot: dependencies.worktreesRoot,
+        },
+        createOttoWorktree: dependencies.createOttoWorktree,
+        resolveDefaultBranch: baseBranch ? async () => baseBranch : undefined,
+        setupContinuation: {
+            kind: "agent",
+            terminalManager: dependencies.terminalManager ?? null,
+            appendTimelineItem: ({ agentId, item }) => appendTimelineItemIfAgentKnown({
+                agentManager: dependencies.agentManager,
+                agentId,
+                item,
+            }),
+            emitLiveTimelineItem: ({ agentId, item }) => emitLiveTimelineItemIfAgentKnown({
+                agentManager: dependencies.agentManager,
+                agentId,
+                item,
+            }),
+            logger: dependencies.logger,
+        },
+    });
+    return {
+        resolvedCwd: createdWorktree.worktree.worktreePath,
+        setupContinuation: createdWorktree.setupContinuation,
+        createdWorkspaceId: createdWorktree.workspace.workspaceId,
+    };
+}
+async function createMcpWorktree(options) {
+    try {
+        if (!options.createOttoWorktree) {
+            throw new Error("Otto worktree service is not configured");
+        }
+        return await options.createOttoWorktree(options.input, {
+            ...(options.resolveDefaultBranch
+                ? { resolveDefaultBranch: options.resolveDefaultBranch }
+                : {}),
+            ...(options.setupContinuation ? { setupContinuation: options.setupContinuation } : {}),
+        });
+    }
+    catch (error) {
+        throw toWorktreeRequestError(error);
+    }
+}
+function mergeLabels(params) {
+    const mergedLabels = {
+        ...(!params.detached && params.callerAgentId
+            ? { [PARENT_AGENT_ID_LABEL]: params.callerAgentId }
+            : {}),
+        ...params.childAgentDefaultLabels,
+        ...params.labels,
+    };
+    if (params.detached) {
+        delete mergedLabels[PARENT_AGENT_ID_LABEL];
+    }
+    return Object.keys(mergedLabels).length > 0 ? mergedLabels : undefined;
+}
+//# sourceMappingURL=create.js.map

package/dist/server/server/agent/create-agent-lifecycle-dispatch.d.ts

@@ -0,0 +1,54 @@
+import type pino from "pino";
+import type { GitHubService } from "../../services/github-service.js";
+import { type ActiveWorkspaceRef } from "../workspace-archive-service.js";
+import type { CreateOttoWorktreeWorkflowFn, CreateOttoWorktreeWorkflowResult } from "../worktree-session.js";
+import type { WorkspaceGitService } from "../workspace-git-service.js";
+import type { CreateAgentWorktreeTarget, FirstAgentContext, SessionOutboundMessage } from "../messages.js";
+import type { AgentManager } from "./agent-manager.js";
+import type { AgentStorage } from "./agent-storage.js";
+interface CreateAgentLifecycleDispatchDependencies {
+    ottoHome: string;
+    worktreesRoot?: string;
+    agentManager: AgentManager;
+    agentStorage: AgentStorage;
+    github: GitHubService;
+    workspaceGitService: WorkspaceGitService;
+    createOttoWorktreeWorkflow: CreateOttoWorktreeWorkflowFn;
+    archiveAgentForClose: (agentId: string) => Promise<unknown>;
+    findWorkspaceIdForCwd: (cwd: string) => Promise<string | null>;
+    listActiveWorkspaces: () => Promise<ActiveWorkspaceRef[]>;
+    archiveWorkspaceRecord: (workspaceId: string) => Promise<void>;
+    emit: (message: SessionOutboundMessage) => void;
+    emitAgentRemove: (agentId: string) => void;
+    emitWorkspaceUpdatesForWorkspaceIds: (workspaceIds: Iterable<string>) => Promise<void>;
+    markWorkspaceArchiving: (workspaceIds: Iterable<string>, archivingAt: string) => void;
+    clearWorkspaceArchiving: (workspaceIds: Iterable<string>) => void;
+    killTerminalsForWorkspace: (workspaceId: string) => Promise<void>;
+    logger: pino.Logger;
+}
+export declare class CreateAgentLifecycleDispatch {
+    private readonly dependencies;
+    private readonly autoArchiveAgentIds;
+    constructor(dependencies: CreateAgentLifecycleDispatchDependencies);
+    createWorktreeForRequest(input: {
+        cwd: string;
+        target: CreateAgentWorktreeTarget | undefined;
+        firstAgentContext: FirstAgentContext;
+        hasLegacyGitOptions: boolean;
+    }): Promise<CreateOttoWorktreeWorkflowResult | null>;
+    registerAutoArchiveIfRequested(input: {
+        autoArchive: boolean | undefined;
+        agentId: string;
+        createdWorktree: CreateOttoWorktreeWorkflowResult | null;
+    }): void;
+    cleanupCreatedWorktreeAfterFailedAgentCreate(input: {
+        createdWorktree: CreateOttoWorktreeWorkflowResult | null;
+        createdAgentId: string | null;
+    }): Promise<void>;
+    private createWorktreeForTarget;
+    private registerAutoArchiveOnTerminalState;
+    private autoArchiveAgentOnce;
+    private archiveAutoCreatedWorktree;
+}
+export {};
+//# sourceMappingURL=create-agent-lifecycle-dispatch.d.ts.map

package/dist/server/server/agent/create-agent-lifecycle-dispatch.js

@@ -0,0 +1,152 @@
+import { randomUUID } from "node:crypto";
+import { isOttoOwnedWorktreeCwd } from "../../utils/worktree.js";
+import { archiveByScope, resolveWorkspaceIdAtPath, } from "../workspace-archive-service.js";
+export class CreateAgentLifecycleDispatch {
+    constructor(dependencies) {
+        this.dependencies = dependencies;
+        this.autoArchiveAgentIds = new Set();
+    }
+    async createWorktreeForRequest(input) {
+        if (input.target && input.hasLegacyGitOptions) {
+            throw new Error("create_agent_request worktree cannot be combined with git options");
+        }
+        if (!input.target) {
+            return null;
+        }
+        return this.createWorktreeForTarget(input.cwd, input.target, input.firstAgentContext);
+    }
+    registerAutoArchiveIfRequested(input) {
+        if (input.autoArchive !== true) {
+            return;
+        }
+        this.registerAutoArchiveOnTerminalState(input.agentId, {
+            worktreePath: input.createdWorktree?.worktree.worktreePath ?? null,
+            repoRoot: input.createdWorktree?.repoRoot ?? null,
+        });
+    }
+    async cleanupCreatedWorktreeAfterFailedAgentCreate(input) {
+        const { createdWorktree, createdAgentId } = input;
+        if (!createdWorktree || createdAgentId) {
+            return;
+        }
+        await this.archiveAutoCreatedWorktree({
+            agentId: null,
+            worktreePath: createdWorktree.worktree.worktreePath,
+            repoRoot: createdWorktree.repoRoot,
+        }).catch((archiveError) => {
+            this.dependencies.logger.warn({
+                err: archiveError,
+                worktreePath: createdWorktree.worktree.worktreePath,
+            }, "Failed to clean up worktree after create_agent_request failed");
+        });
+    }
+    async createWorktreeForTarget(cwd, target, firstAgentContext) {
+        const baseInput = {
+            cwd,
+            firstAgentContext,
+            runSetup: false,
+            ottoHome: this.dependencies.ottoHome,
+            worktreesRoot: this.dependencies.worktreesRoot,
+        };
+        switch (target.mode) {
+            case "branch-off":
+                return this.dependencies.createOttoWorktreeWorkflow({
+                    ...baseInput,
+                    worktreeSlug: target.newBranch,
+                    action: "branch-off",
+                    ...(target.base ? { refName: target.base } : {}),
+                }, target.base ? { resolveDefaultBranch: async () => target.base } : undefined);
+            case "checkout-branch":
+                return this.dependencies.createOttoWorktreeWorkflow({
+                    ...baseInput,
+                    action: "checkout",
+                    refName: target.branch,
+                });
+            case "checkout-pr":
+                return this.dependencies.createOttoWorktreeWorkflow({
+                    ...baseInput,
+                    action: "checkout",
+                    githubPrNumber: target.prNumber,
+                });
+            default:
+                throw new Error("Unsupported create_agent_request worktree target");
+        }
+    }
+    registerAutoArchiveOnTerminalState(agentId, options) {
+        const unsubscribe = this.dependencies.agentManager.subscribe((event) => {
+            if (event.type !== "agent_stream") {
+                return;
+            }
+            if (event.event.type !== "turn_completed" &&
+                event.event.type !== "turn_failed" &&
+                event.event.type !== "turn_canceled") {
+                return;
+            }
+            unsubscribe();
+            void this.autoArchiveAgentOnce(agentId, options);
+        }, { agentId, replayState: false });
+    }
+    async autoArchiveAgentOnce(agentId, options) {
+        if (this.autoArchiveAgentIds.has(agentId)) {
+            return;
+        }
+        this.autoArchiveAgentIds.add(agentId);
+        try {
+            if (options.worktreePath) {
+                await this.archiveAutoCreatedWorktree({
+                    agentId,
+                    worktreePath: options.worktreePath,
+                    repoRoot: options.repoRoot,
+                });
+                return;
+            }
+            await this.dependencies.archiveAgentForClose(agentId);
+        }
+        catch (error) {
+            this.dependencies.logger.warn({ err: error, agentId }, "Failed to auto-archive agent");
+        }
+    }
+    async archiveAutoCreatedWorktree(options) {
+        const ownership = await isOttoOwnedWorktreeCwd(options.worktreePath, {
+            ottoHome: this.dependencies.ottoHome,
+            worktreesRoot: this.dependencies.worktreesRoot,
+        });
+        if (!ownership.allowed) {
+            throw new Error("Auto-created worktree is not a Otto-owned worktree");
+        }
+        const workspaceId = await resolveWorkspaceIdAtPath({
+            findWorkspaceIdForCwd: this.dependencies.findWorkspaceIdForCwd,
+            listActiveWorkspaces: this.dependencies.listActiveWorkspaces,
+        }, options.worktreePath);
+        if (!workspaceId) {
+            this.dependencies.logger.warn({ worktreePath: options.worktreePath }, "Could not resolve workspace for auto-archive; skipping");
+        }
+        else {
+            await archiveByScope({
+                ottoHome: this.dependencies.ottoHome,
+                ottoWorktreesBaseRoot: this.dependencies.worktreesRoot,
+                github: this.dependencies.github,
+                workspaceGitService: this.dependencies.workspaceGitService,
+                agentManager: this.dependencies.agentManager,
+                agentStorage: this.dependencies.agentStorage,
+                findWorkspaceIdForCwd: this.dependencies.findWorkspaceIdForCwd,
+                listActiveWorkspaces: this.dependencies.listActiveWorkspaces,
+                archiveWorkspaceRecord: this.dependencies.archiveWorkspaceRecord,
+                emitWorkspaceUpdatesForWorkspaceIds: this.dependencies.emitWorkspaceUpdatesForWorkspaceIds,
+                markWorkspaceArchiving: this.dependencies.markWorkspaceArchiving,
+                clearWorkspaceArchiving: this.dependencies.clearWorkspaceArchiving,
+                killTerminalsForWorkspace: this.dependencies.killTerminalsForWorkspace,
+                sessionLogger: this.dependencies.logger,
+            }, {
+                scope: { kind: "workspace", workspaceId },
+                repoRoot: options.repoRoot ?? ownership.repoRoot ?? null,
+                ottoWorktreesBaseRoot: this.dependencies.worktreesRoot,
+                requestId: randomUUID(),
+            });
+        }
+        if (options.agentId) {
+            this.dependencies.emitAgentRemove(options.agentId);
+        }
+    }
+}
+//# sourceMappingURL=create-agent-lifecycle-dispatch.js.map

package/dist/server/server/agent/create-agent-mode.d.ts

@@ -0,0 +1,13 @@
+import type { AgentCreateConfigParent, AgentCreateConfigUnattendedInput, AgentProvider, ResolveAgentCreateConfigInput, ResolveAgentCreateConfigResult } from "./agent-sdk-types.js";
+export interface ResolveCreateAgentModeInput {
+    requestedMode: string | undefined;
+    targetProvider: AgentProvider;
+    parent: AgentCreateConfigParent | null;
+    unattended: boolean;
+    availableModes: string[] | undefined;
+    targetUnattendedMode: string | undefined;
+}
+export declare function resolveAndValidateCreateAgentMode(input: ResolveCreateAgentModeInput): string | undefined;
+export declare function resolveDefaultAgentCreateConfig(input: ResolveAgentCreateConfigInput): ResolveAgentCreateConfigResult;
+export declare function isDefaultAgentCreateConfigUnattended(input: AgentCreateConfigUnattendedInput): boolean;
+//# sourceMappingURL=create-agent-mode.d.ts.map

package/dist/server/server/agent/create-agent-mode.js

@@ -0,0 +1,62 @@
+function listModes(modes) {
+    if (modes === undefined) {
+        return "unknown";
+    }
+    return modes.length > 0 ? modes.join(", ") : "(none)";
+}
+function isUnattendedCreateConfigParent(parent) {
+    return parent.isUnattended;
+}
+function formatCreateConfigParentMode(parent) {
+    return parent.modeId ?? "<none>";
+}
+function formatCreateConfigParentSource(parent) {
+    return `caller (provider '${parent.provider}')`;
+}
+export function resolveAndValidateCreateAgentMode(input) {
+    const { requestedMode, targetProvider, parent, availableModes } = input;
+    if (requestedMode !== undefined) {
+        if (availableModes !== undefined && !availableModes.includes(requestedMode)) {
+            throw new Error(`Invalid mode '${requestedMode}' for provider '${targetProvider}'. Available modes: ${listModes(availableModes)}`);
+        }
+        return requestedMode;
+    }
+    if (!parent) {
+        if (input.unattended && input.targetUnattendedMode !== undefined) {
+            return input.targetUnattendedMode;
+        }
+        return undefined;
+    }
+    if (parent.provider === targetProvider) {
+        return parent.modeId ?? undefined;
+    }
+    if ((input.unattended || isUnattendedCreateConfigParent(parent)) &&
+        input.targetUnattendedMode !== undefined) {
+        return input.targetUnattendedMode;
+    }
+    throw new Error(`cannot inherit mode '${formatCreateConfigParentMode(parent)}' from ${formatCreateConfigParentSource(parent)} for new agent (provider '${targetProvider}'). Pass an explicit mode. Available modes for '${targetProvider}': ${listModes(availableModes)}`);
+}
+export function resolveDefaultAgentCreateConfig(input) {
+    const availableModeIds = input.availableModes?.map((mode) => mode.id);
+    return {
+        modeId: resolveAndValidateCreateAgentMode({
+            requestedMode: input.requestedMode,
+            targetProvider: input.provider,
+            parent: input.parent,
+            unattended: input.unattended,
+            availableModes: availableModeIds,
+            targetUnattendedMode: input.availableModes?.find(isUnattendedMode)?.id,
+        }),
+        featureValues: input.featureValues,
+    };
+}
+export function isDefaultAgentCreateConfigUnattended(input) {
+    if (input.modeId === null) {
+        return false;
+    }
+    return input.availableModes.some((mode) => mode.id === input.modeId && isUnattendedMode(mode));
+}
+function isUnattendedMode(mode) {
+    return mode.isUnattended === true;
+}
+//# sourceMappingURL=create-agent-mode.js.map

package/dist/server/server/agent/create-agent-title.d.ts

@@ -0,0 +1,10 @@
+import type { FirstAgentContext } from "@otto-code/protocol/messages";
+export declare function resolveCreateAgentTitles(options: {
+    configTitle?: string | null;
+    initialPrompt?: string | null;
+}): {
+    explicitTitle: string | null;
+    provisionalTitle: string | null;
+};
+export declare function resolveFirstAgentPromptTitle(firstAgentContext?: FirstAgentContext): string | null;
+//# sourceMappingURL=create-agent-title.d.ts.map