agiagent-dev 2026.1.30

package/dist/acp/session.js

@@ -0,0 +1,73 @@
+import { randomUUID } from "node:crypto";
+export function createInMemorySessionStore() {
+    const sessions = new Map();
+    const runIdToSessionId = new Map();
+    const createSession = (params) => {
+        const sessionId = params.sessionId ?? randomUUID();
+        const session = {
+            sessionId,
+            sessionKey: params.sessionKey,
+            cwd: params.cwd,
+            createdAt: Date.now(),
+            abortController: null,
+            activeRunId: null,
+        };
+        sessions.set(sessionId, session);
+        return session;
+    };
+    const getSession = (sessionId) => sessions.get(sessionId);
+    const getSessionByRunId = (runId) => {
+        const sessionId = runIdToSessionId.get(runId);
+        return sessionId ? sessions.get(sessionId) : undefined;
+    };
+    const setActiveRun = (sessionId, runId, abortController) => {
+        const session = sessions.get(sessionId);
+        if (!session) {
+            return;
+        }
+        session.activeRunId = runId;
+        session.abortController = abortController;
+        runIdToSessionId.set(runId, sessionId);
+    };
+    const clearActiveRun = (sessionId) => {
+        const session = sessions.get(sessionId);
+        if (!session) {
+            return;
+        }
+        if (session.activeRunId) {
+            runIdToSessionId.delete(session.activeRunId);
+        }
+        session.activeRunId = null;
+        session.abortController = null;
+    };
+    const cancelActiveRun = (sessionId) => {
+        const session = sessions.get(sessionId);
+        if (!session?.abortController) {
+            return false;
+        }
+        session.abortController.abort();
+        if (session.activeRunId) {
+            runIdToSessionId.delete(session.activeRunId);
+        }
+        session.abortController = null;
+        session.activeRunId = null;
+        return true;
+    };
+    const clearAllSessionsForTest = () => {
+        for (const session of sessions.values()) {
+            session.abortController?.abort();
+        }
+        sessions.clear();
+        runIdToSessionId.clear();
+    };
+    return {
+        createSession,
+        getSession,
+        getSessionByRunId,
+        setActiveRun,
+        clearActiveRun,
+        cancelActiveRun,
+        clearAllSessionsForTest,
+    };
+}
+export const defaultAcpSessionStore = createInMemorySessionStore();

package/dist/acp/translator.d.ts

@@ -0,0 +1,36 @@
+import type { Agent, AgentSideConnection, AuthenticateRequest, AuthenticateResponse, CancelNotification, InitializeRequest, InitializeResponse, ListSessionsRequest, ListSessionsResponse, LoadSessionRequest, LoadSessionResponse, NewSessionRequest, NewSessionResponse, PromptRequest, PromptResponse, SetSessionModeRequest, SetSessionModeResponse } from "@agentclientprotocol/sdk";
+import type { GatewayClient } from "../gateway/client.js";
+import type { EventFrame } from "../gateway/protocol/index.js";
+import { type AcpSessionStore } from "./session.js";
+import { type AcpServerOptions } from "./types.js";
+type AcpGatewayAgentOptions = AcpServerOptions & {
+    sessionStore?: AcpSessionStore;
+};
+export declare class AcpGatewayAgent implements Agent {
+    private connection;
+    private gateway;
+    private opts;
+    private log;
+    private sessionStore;
+    private pendingPrompts;
+    constructor(connection: AgentSideConnection, gateway: GatewayClient, opts?: AcpGatewayAgentOptions);
+    start(): void;
+    handleGatewayReconnect(): void;
+    handleGatewayDisconnect(reason: string): void;
+    handleGatewayEvent(evt: EventFrame): Promise<void>;
+    initialize(_params: InitializeRequest): Promise<InitializeResponse>;
+    newSession(params: NewSessionRequest): Promise<NewSessionResponse>;
+    loadSession(params: LoadSessionRequest): Promise<LoadSessionResponse>;
+    unstable_listSessions(params: ListSessionsRequest): Promise<ListSessionsResponse>;
+    authenticate(_params: AuthenticateRequest): Promise<AuthenticateResponse>;
+    setSessionMode(params: SetSessionModeRequest): Promise<SetSessionModeResponse>;
+    prompt(params: PromptRequest): Promise<PromptResponse>;
+    cancel(params: CancelNotification): Promise<void>;
+    private handleAgentEvent;
+    private handleChatEvent;
+    private handleDeltaEvent;
+    private finishPrompt;
+    private findPendingBySessionKey;
+    private sendAvailableCommands;
+}
+export {};

package/dist/acp/translator.js

@@ -0,0 +1,360 @@
+import { PROTOCOL_VERSION } from "@agentclientprotocol/sdk";
+import { randomUUID } from "node:crypto";
+import { getAvailableCommands } from "./commands.js";
+import { extractAttachmentsFromPrompt, extractTextFromPrompt, formatToolTitle, inferToolKind, } from "./event-mapper.js";
+import { readBool, readNumber, readString } from "./meta.js";
+import { parseSessionMeta, resetSessionIfNeeded, resolveSessionKey } from "./session-mapper.js";
+import { defaultAcpSessionStore } from "./session.js";
+import { ACP_AGENT_INFO } from "./types.js";
+export class AcpGatewayAgent {
+    connection;
+    gateway;
+    opts;
+    log;
+    sessionStore;
+    pendingPrompts = new Map();
+    constructor(connection, gateway, opts = {}) {
+        this.connection = connection;
+        this.gateway = gateway;
+        this.opts = opts;
+        this.log = opts.verbose ? (msg) => process.stderr.write(`[acp] ${msg}\n`) : () => { };
+        this.sessionStore = opts.sessionStore ?? defaultAcpSessionStore;
+    }
+    start() {
+        this.log("ready");
+    }
+    handleGatewayReconnect() {
+        this.log("gateway reconnected");
+    }
+    handleGatewayDisconnect(reason) {
+        this.log(`gateway disconnected: ${reason}`);
+        for (const pending of this.pendingPrompts.values()) {
+            pending.reject(new Error(`Gateway disconnected: ${reason}`));
+            this.sessionStore.clearActiveRun(pending.sessionId);
+        }
+        this.pendingPrompts.clear();
+    }
+    async handleGatewayEvent(evt) {
+        if (evt.event === "chat") {
+            await this.handleChatEvent(evt);
+            return;
+        }
+        if (evt.event === "agent") {
+            await this.handleAgentEvent(evt);
+        }
+    }
+    async initialize(_params) {
+        return {
+            protocolVersion: PROTOCOL_VERSION,
+            agentCapabilities: {
+                loadSession: true,
+                promptCapabilities: {
+                    image: true,
+                    audio: false,
+                    embeddedContext: true,
+                },
+                mcpCapabilities: {
+                    http: false,
+                    sse: false,
+                },
+                sessionCapabilities: {
+                    list: {},
+                },
+            },
+            agentInfo: ACP_AGENT_INFO,
+            authMethods: [],
+        };
+    }
+    async newSession(params) {
+        if (params.mcpServers.length > 0) {
+            this.log(`ignoring ${params.mcpServers.length} MCP servers`);
+        }
+        const sessionId = randomUUID();
+        const meta = parseSessionMeta(params._meta);
+        const sessionKey = await resolveSessionKey({
+            meta,
+            fallbackKey: `acp:${sessionId}`,
+            gateway: this.gateway,
+            opts: this.opts,
+        });
+        await resetSessionIfNeeded({
+            meta,
+            sessionKey,
+            gateway: this.gateway,
+            opts: this.opts,
+        });
+        const session = this.sessionStore.createSession({
+            sessionId,
+            sessionKey,
+            cwd: params.cwd,
+        });
+        this.log(`newSession: ${session.sessionId} -> ${session.sessionKey}`);
+        await this.sendAvailableCommands(session.sessionId);
+        return { sessionId: session.sessionId };
+    }
+    async loadSession(params) {
+        if (params.mcpServers.length > 0) {
+            this.log(`ignoring ${params.mcpServers.length} MCP servers`);
+        }
+        const meta = parseSessionMeta(params._meta);
+        const sessionKey = await resolveSessionKey({
+            meta,
+            fallbackKey: params.sessionId,
+            gateway: this.gateway,
+            opts: this.opts,
+        });
+        await resetSessionIfNeeded({
+            meta,
+            sessionKey,
+            gateway: this.gateway,
+            opts: this.opts,
+        });
+        const session = this.sessionStore.createSession({
+            sessionId: params.sessionId,
+            sessionKey,
+            cwd: params.cwd,
+        });
+        this.log(`loadSession: ${session.sessionId} -> ${session.sessionKey}`);
+        await this.sendAvailableCommands(session.sessionId);
+        return {};
+    }
+    async unstable_listSessions(params) {
+        const limit = readNumber(params._meta, ["limit"]) ?? 100;
+        const result = await this.gateway.request("sessions.list", { limit });
+        const cwd = params.cwd ?? process.cwd();
+        return {
+            sessions: result.sessions.map((session) => ({
+                sessionId: session.key,
+                cwd,
+                title: session.displayName ?? session.label ?? session.key,
+                updatedAt: session.updatedAt ? new Date(session.updatedAt).toISOString() : undefined,
+                _meta: {
+                    sessionKey: session.key,
+                    kind: session.kind,
+                    channel: session.channel,
+                },
+            })),
+            nextCursor: null,
+        };
+    }
+    async authenticate(_params) {
+        return {};
+    }
+    async setSessionMode(params) {
+        const session = this.sessionStore.getSession(params.sessionId);
+        if (!session) {
+            throw new Error(`Session ${params.sessionId} not found`);
+        }
+        if (!params.modeId) {
+            return {};
+        }
+        try {
+            await this.gateway.request("sessions.patch", {
+                key: session.sessionKey,
+                thinkingLevel: params.modeId,
+            });
+            this.log(`setSessionMode: ${session.sessionId} -> ${params.modeId}`);
+        }
+        catch (err) {
+            this.log(`setSessionMode error: ${String(err)}`);
+        }
+        return {};
+    }
+    async prompt(params) {
+        const session = this.sessionStore.getSession(params.sessionId);
+        if (!session) {
+            throw new Error(`Session ${params.sessionId} not found`);
+        }
+        if (session.abortController) {
+            this.sessionStore.cancelActiveRun(params.sessionId);
+        }
+        const abortController = new AbortController();
+        const runId = randomUUID();
+        this.sessionStore.setActiveRun(params.sessionId, runId, abortController);
+        const meta = parseSessionMeta(params._meta);
+        const userText = extractTextFromPrompt(params.prompt);
+        const attachments = extractAttachmentsFromPrompt(params.prompt);
+        const prefixCwd = meta.prefixCwd ?? this.opts.prefixCwd ?? true;
+        const message = prefixCwd ? `[Working directory: ${session.cwd}]\n\n${userText}` : userText;
+        return new Promise((resolve, reject) => {
+            this.pendingPrompts.set(params.sessionId, {
+                sessionId: params.sessionId,
+                sessionKey: session.sessionKey,
+                idempotencyKey: runId,
+                resolve,
+                reject,
+            });
+            this.gateway
+                .request("chat.send", {
+                sessionKey: session.sessionKey,
+                message,
+                attachments: attachments.length > 0 ? attachments : undefined,
+                idempotencyKey: runId,
+                thinking: readString(params._meta, ["thinking", "thinkingLevel"]),
+                deliver: readBool(params._meta, ["deliver"]),
+                timeoutMs: readNumber(params._meta, ["timeoutMs"]),
+            }, { expectFinal: true })
+                .catch((err) => {
+                this.pendingPrompts.delete(params.sessionId);
+                this.sessionStore.clearActiveRun(params.sessionId);
+                reject(err instanceof Error ? err : new Error(String(err)));
+            });
+        });
+    }
+    async cancel(params) {
+        const session = this.sessionStore.getSession(params.sessionId);
+        if (!session) {
+            return;
+        }
+        this.sessionStore.cancelActiveRun(params.sessionId);
+        try {
+            await this.gateway.request("chat.abort", { sessionKey: session.sessionKey });
+        }
+        catch (err) {
+            this.log(`cancel error: ${String(err)}`);
+        }
+        const pending = this.pendingPrompts.get(params.sessionId);
+        if (pending) {
+            this.pendingPrompts.delete(params.sessionId);
+            pending.resolve({ stopReason: "cancelled" });
+        }
+    }
+    async handleAgentEvent(evt) {
+        const payload = evt.payload;
+        if (!payload) {
+            return;
+        }
+        const stream = payload.stream;
+        const data = payload.data;
+        const sessionKey = payload.sessionKey;
+        if (!stream || !data || !sessionKey) {
+            return;
+        }
+        if (stream !== "tool") {
+            return;
+        }
+        const phase = data.phase;
+        const name = data.name;
+        const toolCallId = data.toolCallId;
+        if (!toolCallId) {
+            return;
+        }
+        const pending = this.findPendingBySessionKey(sessionKey);
+        if (!pending) {
+            return;
+        }
+        if (phase === "start") {
+            if (!pending.toolCalls) {
+                pending.toolCalls = new Set();
+            }
+            if (pending.toolCalls.has(toolCallId)) {
+                return;
+            }
+            pending.toolCalls.add(toolCallId);
+            const args = data.args;
+            await this.connection.sessionUpdate({
+                sessionId: pending.sessionId,
+                update: {
+                    sessionUpdate: "tool_call",
+                    toolCallId,
+                    title: formatToolTitle(name, args),
+                    status: "in_progress",
+                    rawInput: args,
+                    kind: inferToolKind(name),
+                },
+            });
+            return;
+        }
+        if (phase === "result") {
+            const isError = Boolean(data.isError);
+            await this.connection.sessionUpdate({
+                sessionId: pending.sessionId,
+                update: {
+                    sessionUpdate: "tool_call_update",
+                    toolCallId,
+                    status: isError ? "failed" : "completed",
+                    rawOutput: data.result,
+                },
+            });
+        }
+    }
+    async handleChatEvent(evt) {
+        const payload = evt.payload;
+        if (!payload) {
+            return;
+        }
+        const sessionKey = payload.sessionKey;
+        const state = payload.state;
+        const runId = payload.runId;
+        const messageData = payload.message;
+        if (!sessionKey || !state) {
+            return;
+        }
+        const pending = this.findPendingBySessionKey(sessionKey);
+        if (!pending) {
+            return;
+        }
+        if (runId && pending.idempotencyKey !== runId) {
+            return;
+        }
+        if (state === "delta" && messageData) {
+            await this.handleDeltaEvent(pending.sessionId, messageData);
+            return;
+        }
+        if (state === "final") {
+            this.finishPrompt(pending.sessionId, pending, "end_turn");
+            return;
+        }
+        if (state === "aborted") {
+            this.finishPrompt(pending.sessionId, pending, "cancelled");
+            return;
+        }
+        if (state === "error") {
+            this.finishPrompt(pending.sessionId, pending, "refusal");
+        }
+    }
+    async handleDeltaEvent(sessionId, messageData) {
+        const content = messageData.content;
+        const fullText = content?.find((c) => c.type === "text")?.text ?? "";
+        const pending = this.pendingPrompts.get(sessionId);
+        if (!pending) {
+            return;
+        }
+        const sentSoFar = pending.sentTextLength ?? 0;
+        if (fullText.length <= sentSoFar) {
+            return;
+        }
+        const newText = fullText.slice(sentSoFar);
+        pending.sentTextLength = fullText.length;
+        pending.sentText = fullText;
+        await this.connection.sessionUpdate({
+            sessionId,
+            update: {
+                sessionUpdate: "agent_message_chunk",
+                content: { type: "text", text: newText },
+            },
+        });
+    }
+    finishPrompt(sessionId, pending, stopReason) {
+        this.pendingPrompts.delete(sessionId);
+        this.sessionStore.clearActiveRun(sessionId);
+        pending.resolve({ stopReason });
+    }
+    findPendingBySessionKey(sessionKey) {
+        for (const pending of this.pendingPrompts.values()) {
+            if (pending.sessionKey === sessionKey) {
+                return pending;
+            }
+        }
+        return undefined;
+    }
+    async sendAvailableCommands(sessionId) {
+        await this.connection.sessionUpdate({
+            sessionId,
+            update: {
+                sessionUpdate: "available_commands_update",
+                availableCommands: getAvailableCommands(),
+            },
+        });
+    }
+}

package/dist/acp/types.d.ts

@@ -0,0 +1,25 @@
+import type { SessionId } from "@agentclientprotocol/sdk";
+export type AcpSession = {
+    sessionId: SessionId;
+    sessionKey: string;
+    cwd: string;
+    createdAt: number;
+    abortController: AbortController | null;
+    activeRunId: string | null;
+};
+export type AcpServerOptions = {
+    gatewayUrl?: string;
+    gatewayToken?: string;
+    gatewayPassword?: string;
+    defaultSessionKey?: string;
+    defaultSessionLabel?: string;
+    requireExistingSession?: boolean;
+    resetSession?: boolean;
+    prefixCwd?: boolean;
+    verbose?: boolean;
+};
+export declare const ACP_AGENT_INFO: {
+    name: string;
+    title: string;
+    version: string;
+};

package/dist/acp/types.js

@@ -0,0 +1,6 @@
+import { VERSION } from "../version.js";
+export const ACP_AGENT_INFO = {
+    name: "agiagent-acp",
+    title: "AGIAgent ACP Gateway",
+    version: VERSION,
+};

package/dist/agents/agent-paths.d.ts

@@ -0,0 +1,2 @@
+export declare function resolveAGIAgentAgentDir(): string;
+export declare function ensureAGIAgentAgentEnv(): string;

package/dist/agents/agent-paths.js

@@ -0,0 +1,22 @@
+import path from "node:path";
+import { resolveStateDir } from "../config/paths.js";
+import { DEFAULT_AGENT_ID } from "../routing/session-key.js";
+import { resolveUserPath } from "../utils.js";
+export function resolveAGIAgentAgentDir() {
+    const override = process.env.AGIAGENT_AGENT_DIR?.trim() || process.env.PI_CODING_AGENT_DIR?.trim();
+    if (override) {
+        return resolveUserPath(override);
+    }
+    const defaultAgentDir = path.join(resolveStateDir(), "agents", DEFAULT_AGENT_ID, "agent");
+    return resolveUserPath(defaultAgentDir);
+}
+export function ensureAGIAgentAgentEnv() {
+    const dir = resolveAGIAgentAgentDir();
+    if (!process.env.AGIAGENT_AGENT_DIR) {
+        process.env.AGIAGENT_AGENT_DIR = dir;
+    }
+    if (!process.env.PI_CODING_AGENT_DIR) {
+        process.env.PI_CODING_AGENT_DIR = dir;
+    }
+    return dir;
+}

package/dist/agents/agent-scope.d.ts

@@ -0,0 +1,35 @@
+import type { AGIAgentConfig } from "../config/config.js";
+export { resolveAgentIdFromSessionKey } from "../routing/session-key.js";
+type AgentEntry = NonNullable<NonNullable<AGIAgentConfig["agents"]>["list"]>[number];
+type ResolvedAgentConfig = {
+    name?: string;
+    workspace?: string;
+    agentDir?: string;
+    model?: AgentEntry["model"];
+    memorySearch?: AgentEntry["memorySearch"];
+    humanDelay?: AgentEntry["humanDelay"];
+    heartbeat?: AgentEntry["heartbeat"];
+    identity?: AgentEntry["identity"];
+    groupChat?: AgentEntry["groupChat"];
+    subagents?: AgentEntry["subagents"];
+    sandbox?: AgentEntry["sandbox"];
+    tools?: AgentEntry["tools"];
+};
+export declare function listAgentIds(cfg: AGIAgentConfig): string[];
+export declare function resolveDefaultAgentId(cfg: AGIAgentConfig): string;
+export declare function resolveSessionAgentIds(params: {
+    sessionKey?: string;
+    config?: AGIAgentConfig;
+}): {
+    defaultAgentId: string;
+    sessionAgentId: string;
+};
+export declare function resolveSessionAgentId(params: {
+    sessionKey?: string;
+    config?: AGIAgentConfig;
+}): string;
+export declare function resolveAgentConfig(cfg: AGIAgentConfig, agentId: string): ResolvedAgentConfig | undefined;
+export declare function resolveAgentModelPrimary(cfg: AGIAgentConfig, agentId: string): string | undefined;
+export declare function resolveAgentModelFallbacksOverride(cfg: AGIAgentConfig, agentId: string): string[] | undefined;
+export declare function resolveAgentWorkspaceDir(cfg: AGIAgentConfig, agentId: string): string;
+export declare function resolveAgentDir(cfg: AGIAgentConfig, agentId: string): string;

package/dist/agents/agent-scope.js

@@ -0,0 +1,130 @@
+import os from "node:os";
+import path from "node:path";
+import { resolveStateDir } from "../config/paths.js";
+import { DEFAULT_AGENT_ID, normalizeAgentId, parseAgentSessionKey, } from "../routing/session-key.js";
+import { resolveUserPath } from "../utils.js";
+import { DEFAULT_AGENT_WORKSPACE_DIR } from "./workspace.js";
+export { resolveAgentIdFromSessionKey } from "../routing/session-key.js";
+let defaultAgentWarned = false;
+function listAgents(cfg) {
+    const list = cfg.agents?.list;
+    if (!Array.isArray(list)) {
+        return [];
+    }
+    return list.filter((entry) => Boolean(entry && typeof entry === "object"));
+}
+export function listAgentIds(cfg) {
+    const agents = listAgents(cfg);
+    if (agents.length === 0) {
+        return [DEFAULT_AGENT_ID];
+    }
+    const seen = new Set();
+    const ids = [];
+    for (const entry of agents) {
+        const id = normalizeAgentId(entry?.id);
+        if (seen.has(id)) {
+            continue;
+        }
+        seen.add(id);
+        ids.push(id);
+    }
+    return ids.length > 0 ? ids : [DEFAULT_AGENT_ID];
+}
+export function resolveDefaultAgentId(cfg) {
+    const agents = listAgents(cfg);
+    if (agents.length === 0) {
+        return DEFAULT_AGENT_ID;
+    }
+    const defaults = agents.filter((agent) => agent?.default);
+    if (defaults.length > 1 && !defaultAgentWarned) {
+        defaultAgentWarned = true;
+        console.warn("Multiple agents marked default=true; using the first entry as default.");
+    }
+    const chosen = (defaults[0] ?? agents[0])?.id?.trim();
+    return normalizeAgentId(chosen || DEFAULT_AGENT_ID);
+}
+export function resolveSessionAgentIds(params) {
+    const defaultAgentId = resolveDefaultAgentId(params.config ?? {});
+    const sessionKey = params.sessionKey?.trim();
+    const normalizedSessionKey = sessionKey ? sessionKey.toLowerCase() : undefined;
+    const parsed = normalizedSessionKey ? parseAgentSessionKey(normalizedSessionKey) : null;
+    const sessionAgentId = parsed?.agentId ? normalizeAgentId(parsed.agentId) : defaultAgentId;
+    return { defaultAgentId, sessionAgentId };
+}
+export function resolveSessionAgentId(params) {
+    return resolveSessionAgentIds(params).sessionAgentId;
+}
+function resolveAgentEntry(cfg, agentId) {
+    const id = normalizeAgentId(agentId);
+    return listAgents(cfg).find((entry) => normalizeAgentId(entry.id) === id);
+}
+export function resolveAgentConfig(cfg, agentId) {
+    const id = normalizeAgentId(agentId);
+    const entry = resolveAgentEntry(cfg, id);
+    if (!entry) {
+        return undefined;
+    }
+    return {
+        name: typeof entry.name === "string" ? entry.name : undefined,
+        workspace: typeof entry.workspace === "string" ? entry.workspace : undefined,
+        agentDir: typeof entry.agentDir === "string" ? entry.agentDir : undefined,
+        model: typeof entry.model === "string" || (entry.model && typeof entry.model === "object")
+            ? entry.model
+            : undefined,
+        memorySearch: entry.memorySearch,
+        humanDelay: entry.humanDelay,
+        heartbeat: entry.heartbeat,
+        identity: entry.identity,
+        groupChat: entry.groupChat,
+        subagents: typeof entry.subagents === "object" && entry.subagents ? entry.subagents : undefined,
+        sandbox: entry.sandbox,
+        tools: entry.tools,
+    };
+}
+export function resolveAgentModelPrimary(cfg, agentId) {
+    const raw = resolveAgentConfig(cfg, agentId)?.model;
+    if (!raw) {
+        return undefined;
+    }
+    if (typeof raw === "string") {
+        return raw.trim() || undefined;
+    }
+    const primary = raw.primary?.trim();
+    return primary || undefined;
+}
+export function resolveAgentModelFallbacksOverride(cfg, agentId) {
+    const raw = resolveAgentConfig(cfg, agentId)?.model;
+    if (!raw || typeof raw === "string") {
+        return undefined;
+    }
+    // Important: treat an explicitly provided empty array as an override to disable global fallbacks.
+    if (!Object.hasOwn(raw, "fallbacks")) {
+        return undefined;
+    }
+    return Array.isArray(raw.fallbacks) ? raw.fallbacks : undefined;
+}
+export function resolveAgentWorkspaceDir(cfg, agentId) {
+    const id = normalizeAgentId(agentId);
+    const configured = resolveAgentConfig(cfg, id)?.workspace?.trim();
+    if (configured) {
+        return resolveUserPath(configured);
+    }
+    const defaultAgentId = resolveDefaultAgentId(cfg);
+    if (id === defaultAgentId) {
+        const fallback = cfg.agents?.defaults?.workspace?.trim();
+        if (fallback) {
+            return resolveUserPath(fallback);
+        }
+        return DEFAULT_AGENT_WORKSPACE_DIR;
+    }
+    return path.join(os.homedir(), ".agiagent", `workspace-${id}`);
+}
+export function resolveAgentDir(cfg, agentId) {
+    const id = normalizeAgentId(agentId);
+    const configured = resolveAgentConfig(cfg, id)?.agentDir?.trim();
+    if (configured) {
+        return resolveUserPath(configured);
+    }
+    const root = resolveStateDir(process.env, os.homedir);
+    return path.join(root, "agents", id, "agent");
+}