atom-agent 1.2.0 → 1.3.0

package/dist/tools/provider-hooks.js

@@ -0,0 +1,224 @@
+// Provider request/response hooks (ticket 08): extension hooks over every
+// live model POST (redaction, routing, logging, header injection).
+//
+// Dependency-free like intercept.ts (type-only imports) so the extension
+// host, the transports (zen.ts), and the tests can all share it with no
+// cycle: extensions register here, the transports apply here, nobody imports
+// the other.
+//
+// Semantics (fail-open vs fail-closed per hook):
+// - Context transform (fail OPEN): handlers run in registration order over
+//   the outgoing messages; each sees the previous handler's output and may
+//   return a replacement array (void/null/undefined passes through). A
+//   throwing handler — or a non-array / malformed-array return — degrades to
+//   the untransformed value so far, never a broken request. Fail-open (not
+//   fail-closed like before-tool-call) because there is no unsafe execution
+//   to prevent here — only request shaping — and a buggy redactor must not
+//   hold every model round hostage (same rationale as the before_switch
+//   fail-open gate). Extensions needing guaranteed redaction keep handlers
+//   total (try/catch inside the handler).
+// - Pre-request (fail OPEN): handlers run in registration order over the
+//   assembled payload + headers; each sees the previous handler's output and
+//   may return { payload } to replace the body wholesale and/or { headers }
+//   to set per-key values. A throwing handler is skipped (its change
+//   dropped, the chain continues) so one buggy header injection never fails
+//   the turn. A non-record payload replacement is ignored — the replacement
+//   still flows through the downstream JSON/fetch handling, never bypassing
+//   it. Header merge is per-key: a string sets/overwrites, null/undefined
+//   DELETES the key, anything else is ignored (never silently stringified).
+// - Post-response (fail OPEN, observe-only): handlers run in registration
+//   order with a { provider, model, url, status, ok, headers } snapshot after
+//   every resolved POST (ok and HTTP-error alike; network throws have no
+//   response to observe and never fire). Return values are ignored; a
+//   throwing handler is dropped and the turn continues untouched.
+//
+// Coverage: the three transports in zen.ts (openai-chat via chatCompletion,
+// anthropic-messages via chatCompletionAnthropic, gemini-generate via
+// chatCompletionGemini) each apply all three hooks per POST, so every
+// provider kind — zen, kilo, openai, deepseek, mistral, openai-compatible,
+// local runtimes, anthropic, google-gemini — is covered through the single
+// chatCompletionForProvider dispatcher (which delegates to those three).
+// The loop transcript itself is never mutated: hooks transform per-POST
+// copies only.
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+const VALID_ROLES = new Set(["system", "user", "assistant", "tool"]);
+function isMessages(value) {
+    if (!Array.isArray(value))
+        return false;
+    for (const m of value) {
+        if (!isRecord(m))
+            return false;
+        if (typeof m["role"] !== "string" || !VALID_ROLES.has(m["role"]))
+            return false;
+    }
+    return true;
+}
+const contextHandlers = [];
+const beforeRequestHandlers = [];
+const afterResponseHandlers = [];
+function registerOwned(store, handler, owner, what) {
+    if (typeof handler !== "function") {
+        throw new Error(`${what} handler must be a function`);
+    }
+    const record = { owner, handler };
+    store.push(record);
+    let live = true;
+    return () => {
+        if (!live)
+            return;
+        live = false;
+        const idx = store.indexOf(record);
+        if (idx >= 0)
+            store.splice(idx, 1);
+    };
+}
+/** Register an outgoing-context transformer. Returns an unregister function. */
+export function registerContextTransform(handler, owner = "(unknown)") {
+    return registerOwned(contextHandlers, handler, owner, "context-transform");
+}
+/** Register a pre-request payload/header hook. Returns an unregister function. */
+export function registerBeforeRequest(handler, owner = "(unknown)") {
+    return registerOwned(beforeRequestHandlers, handler, owner, "before-request");
+}
+/** Register a post-response observer. Returns an unregister function. */
+export function registerAfterResponse(handler, owner = "(unknown)") {
+    return registerOwned(afterResponseHandlers, handler, owner, "after-response");
+}
+/** Snapshot of live context handlers in registration order (deterministic composition). */
+export function contextTransformers() {
+    return [...contextHandlers];
+}
+/** Snapshot of live pre-request handlers in registration order. */
+export function beforeRequestInterceptors() {
+    return [...beforeRequestHandlers];
+}
+/** Snapshot of live post-response observers in registration order. */
+export function afterResponseObservers() {
+    return [...afterResponseHandlers];
+}
+/** Test seam: drop every provider hook. */
+export function clearProviderHooks() {
+    contextHandlers.length = 0;
+    beforeRequestHandlers.length = 0;
+    afterResponseHandlers.length = 0;
+}
+// Apply context handlers sequentially in registration order. Never throws:
+// a throwing (or malformed-returning) handler degrades to the value so far.
+export async function applyContextTransform(handlers, messages) {
+    // The first handler receives a deep copy, never the loop's live array:
+    // in-place mutation by a handler must not corrupt the transcript (the
+    // zen.ts call-site contract). structuredClone covers plain chat payloads;
+    // the JSON fallback covers exotic values; live is the last resort.
+    let current;
+    try {
+        current = structuredClone(messages);
+    }
+    catch {
+        try {
+            current = JSON.parse(JSON.stringify(messages));
+        }
+        catch {
+            current = messages;
+        }
+    }
+    for (const record of handlers) {
+        let next;
+        try {
+            next = await record.handler(current);
+        }
+        catch {
+            continue;
+        }
+        if (next === undefined || next === null)
+            continue;
+        if (!isMessages(next))
+            continue;
+        current = next;
+    }
+    return current;
+}
+// Apply pre-request handlers sequentially; each sees the previous output.
+// Never throws: a throwing handler is skipped, a non-record payload is
+// ignored, and header values merge per-key (string sets, null/undefined
+// deletes, anything else ignored).
+export async function applyBeforeRequest(handlers, input) {
+    let payload = input.payload;
+    let headers = { ...input.headers };
+    for (const record of handlers) {
+        let decision;
+        try {
+            decision = await record.handler({
+                provider: input.provider,
+                model: input.model,
+                url: input.url,
+                payload,
+                headers: { ...headers },
+            });
+        }
+        catch {
+            continue;
+        }
+        if (!isRecord(decision))
+            continue;
+        const rep = decision["payload"];
+        if (rep !== undefined && isRecord(rep))
+            payload = rep;
+        const hm = decision["headers"];
+        if (isRecord(hm)) {
+            for (const [k, v] of Object.entries(hm)) {
+                if (typeof v === "string")
+                    headers[k] = v;
+                else if (v === null || v === undefined)
+                    delete headers[k];
+            }
+        }
+    }
+    return { payload, headers };
+}
+// Notify post-response observers sequentially. Never throws and never
+// rejects: observer failures are dropped, the turn continues untouched.
+export async function notifyAfterResponse(handlers, input) {
+    for (const record of handlers) {
+        try {
+            await record.handler(input);
+        }
+        catch {
+            // observe-only: failures never break the turn
+        }
+    }
+}
+/**
+ * Snapshot response headers into a plain record. Never throws: unknown
+ * shapes (mocks with a bare .get, missing headers) yield {}.
+ */
+export function snapshotResponseHeaders(res) {
+    const out = {};
+    try {
+        const headers = res?.headers;
+        if (headers === null || headers === undefined)
+            return out;
+        const forEach = headers.forEach;
+        if (typeof forEach === "function") {
+            forEach.call(headers, (v, k) => {
+                if (typeof k === "string" && typeof v === "string")
+                    out[k.toLowerCase()] = v;
+            });
+            return out;
+        }
+        const iter = headers[Symbol.iterator];
+        if (typeof iter === "function") {
+            for (const entry of headers) {
+                if (Array.isArray(entry) && typeof entry[0] === "string" && typeof entry[1] === "string") {
+                    out[entry[0].toLowerCase()] = entry[1];
+                }
+            }
+            return out;
+        }
+    }
+    catch {
+        // fall through to {}
+    }
+    return out;
+}

package/dist/tools/registry.js

@@ -7,6 +7,14 @@ import { editTool, readTool, writeTool, } from "./filesystem.js";
 import { GREP_OUTPUT_MODES, globTool, grepTool } from "./search.js";
 import { bashOutputTool, bashTool, } from "./shell.js";
 import { err, invalidCall } from "./shared.js";
+import { clearCustomTools, customToolNames, getCustomTool, isCustomTool, listCustomTools, registerCustomTool, unregisterCustomTool, validateCustomToolArgs, validateExtensionToolDef, } from "./custom.js";
+export { validateExtensionToolDef } from "./custom.js";
+import { getToolOverride, isToolOverridden, registerToolOverride, unregisterToolOverride, validateExtensionToolOverrideDef, } from "./overrides.js";
+// NOTE: the override/prompt-hint store functions (registerToolOverride,
+// getToolOverride, getExtensionPromptHints, ...) are intentionally NOT
+// re-exported here as values: the tools barrel star-exports both this module
+// and overrides.js, so a value re-export would make those names ambiguous.
+// Import them from "./tools/overrides.js" (or "../src/tools.js") directly.
 import { todoGetTool, todoUpdateTool, todowriteTool, } from "./todo.js";
 import { webfetchTool, websearchTool, } from "./web.js";
 export const MAX_TOOL_STEPS = 30;
@@ -23,13 +31,49 @@ export const MAX_TOOL_STEPS = 30;
 export const READ_ONLY_TOOLS = new Set(["read", "grep", "glob", "webfetch", "websearch", "bash_output", "todowrite", "todo_get", "todo_update"]);
 export const APPROVAL_TOOLS = new Set(["write", "edit", "bash"]);
 export function needsApproval(name) {
-    return APPROVAL_TOOLS.has(name);
+    if (APPROVAL_TOOLS.has(name))
+        return true;
+    // Approval policy for extension tools: custom tools REQUIRE approval by
+    // default. Extension code runs with full user privileges and its footprint
+    // is invisible to the scheduler, so fail-closed is the only safe default.
+    // An extension may opt out per tool with requireApproval:false, reserved
+    // for pure side-effect-free helpers — the opt-out is explicit at
+    // registration, never ambient.
+    const custom = getCustomTool(name);
+    if (custom)
+        return custom.requireApproval;
+    return false;
 }
-// Known tool names (single source: TOOL_DEFINITIONS, defined below). The
-// validator + loop build "Available: ..." lists from this so the message
-// can never drift from the schema.
+// Known tool names (single source: builtin TOOL_DEFINITIONS plus
+// extension-registered custom tools, defined below). The validator + loop
+// build "Available: ..." lists from this so the message can never drift
+// from the schema.
 export function toolNames() {
-    return TOOL_DEFINITIONS.map((t) => t.function.name);
+    return [...TOOL_DEFINITIONS.map((t) => t.function.name), ...customToolNames()];
+}
+// Every definition the model sees: builtins plus extension tools. The raw
+// TOOL_DEFINITIONS export stays builtin-only (tests pin its 13 entries);
+// chat payloads must use this so custom tools are discoverable. A builtin
+// shadowed by an extension override (ticket 06) keeps its name, schema, and
+// position, but its description carries an audit-visible override marker so
+// the shadowing is never silent.
+export function allToolDefinitions() {
+    return [
+        ...TOOL_DEFINITIONS.map((t) => isToolOverridden(t.function.name)
+            ? {
+                type: "function",
+                function: {
+                    name: t.function.name,
+                    description: `${t.function.description}\n[overridden by extension "${getToolOverride(t.function.name).owner}"]`,
+                    parameters: t.function.parameters,
+                },
+            }
+            : t),
+        ...listCustomTools().map((c) => ({
+            type: "function",
+            function: { name: c.name, description: c.description, parameters: c.parameters },
+        })),
+    ];
 }
 function typeLabel(v) {
     if (v === null)
@@ -81,6 +125,10 @@ export function validateToolArgs(name, args) {
     if (typeof args !== "object" || args === null || Array.isArray(args)) {
         return `arguments for tool "${name}" must be an object. Expected ${expectedShape(name)}`;
     }
+    // Extension tools validate against their own parameters schema (same
+    // invalidCall framing as builtins: the tool never runs on bad args).
+    if (isCustomTool(name))
+        return validateCustomToolArgs(name, args);
     const a = args;
     const exp = expectedShape(name);
     switch (name) {
@@ -270,6 +318,65 @@ export async function executeTool(name, args, cwd = process.cwd()) {
     if (!known.has(name)) {
         return `Error: unknown tool "${name}". Available: ${toolNames().join(", ")}`;
     }
+    // Extension tools run through the same validate-then-execute gate as
+    // builtins: bad args are inline model-visible errors, and a throwing
+    // implementation degrades to an `Error:` result string — never a crash, so
+    // call pairing in the loop stays valid.
+    if (isCustomTool(name)) {
+        const custom = getCustomTool(name);
+        if (!custom) {
+            return `Error: unknown tool "${name}". Available: ${toolNames().join(", ")}`;
+        }
+        const detail = validateToolArgs(name, a);
+        if (detail)
+            return invalidCall(detail);
+        try {
+            const out = await custom.execute(a, { cwd });
+            if (typeof out === "string")
+                return out;
+            try {
+                return JSON.stringify(out) ?? String(out);
+            }
+            catch {
+                return String(out);
+            }
+        }
+        catch (e) {
+            return e instanceof Error ? `Error: ${e.message}` : `Error: ${String(e)}`;
+        }
+    }
+    // Extension override (ticket 06): an explicitly shadowed builtin routes
+    // through the override, which decides per call — deny a subset with a
+    // reason (throw, or return an `Error:` result) or pass the rest through
+    // via ctx.passthrough (the default). Builtin arg validation runs first on
+    // the received args, exactly as without the override, so model mistakes
+    // never reach extension code; the passthrough re-validates whatever it is
+    // given, so the override can never smuggle unvalidated args into the
+    // pristine builtin. A throwing override degrades to an `Error:` result
+    // string — never a crash, so call pairing in the loop stays valid.
+    const override = getToolOverride(name);
+    if (override) {
+        const overrideDetail = validateToolArgs(name, a);
+        if (overrideDetail)
+            return invalidCall(overrideDetail);
+        try {
+            const out = await override.execute(a, {
+                cwd,
+                passthrough: (passthroughArgs = a) => executeBuiltinTool(name, passthroughArgs, cwd),
+            });
+            if (typeof out === "string")
+                return out;
+            try {
+                return JSON.stringify(out) ?? String(out);
+            }
+            catch {
+                return String(out);
+            }
+        }
+        catch (e) {
+            return e instanceof Error ? `Error: ${e.message}` : `Error: ${String(e)}`;
+        }
+    }
     // ask_question keeps its dedicated hook-missing path, but validation
     // still comes first (validateAskQuestionArgs already uses invalidCall).
     if (name === "ask_question") {
@@ -282,40 +389,70 @@ export async function executeTool(name, args, cwd = process.cwd()) {
         return err("ask_question has no UI hook");
     }
     const detail = validateToolArgs(name, a);
+    if (detail)
+        return invalidCall(detail);
+    return executeBuiltinTool(name, a, cwd);
+}
+// Pristine builtin execution (ticket 06: the override passthrough target).
+// Validation first, then the builtin executor — exactly the path above, so
+// pass-through behavior is byte-identical to no override. Never consults the
+// override store, so recursion is impossible by construction. A throwing
+// executor degrades to an `Error:` result string, never a crash.
+async function executeBuiltinTool(name, args, cwd) {
+    // ask_question keeps its dedicated hook-missing path, but validation
+    // still comes first (validateAskQuestionArgs already uses invalidCall).
+    if (name === "ask_question") {
+        // No UI hook at this layer: the agentic loop intercepts ask_question
+        // and serves it via its askUser hook. Direct calls validate, then
+        // report the missing hook as a result string (never throw).
+        const invalid = validateAskQuestionArgs(args);
+        if (invalid)
+            return invalid;
+        return err("ask_question has no UI hook");
+    }
+    const detail = validateToolArgs(name, args);
     if (detail)
         return invalidCall(detail);
     switch (name) {
         case "read":
-            return readTool(a, cwd);
+            return readTool(args, cwd);
         case "write":
-            return writeTool(a, cwd);
+            return writeTool(args, cwd);
         case "glob":
-            return globTool(a, cwd);
+            return globTool(args, cwd);
         case "grep":
-            return grepTool(a, cwd);
+            return grepTool(args, cwd);
         case "edit":
-            return editTool(a, cwd);
+            return editTool(args, cwd);
         case "bash":
-            return bashTool(a, cwd);
+            return bashTool(args, cwd);
         case "bash_output":
-            return bashOutputTool(a);
+            return bashOutputTool(args);
         case "webfetch":
-            return webfetchTool(a);
+            return webfetchTool(args);
         case "websearch":
-            return websearchTool(a);
+            return websearchTool(args);
         case "todowrite":
-            return todowriteTool(a);
+            return todowriteTool(args);
         case "todo_get":
             return todoGetTool();
         case "todo_update":
-            return todoUpdateTool(a);
+            return todoUpdateTool(args);
         default:
             // Unreachable: unknown names return above with the Available list.
             return `Error: unknown tool "${name}". Available: ${toolNames().join(", ")}`;
     }
 }
-// One-line TUI label for a tool call, e.g. "⚙ read src/zen.ts".
+// One-line TUI label for a tool call, e.g. "⚙ read src/zen.ts". A call to
+// a shadowed builtin (ticket 06) carries an audit-visible override suffix
+// so the shadowing is visible in the activity line too — pristine builtins
+// render byte-identically to before.
 export function describeToolCall(name, args) {
+    const label = describeToolCallBase(name, args);
+    const over = getToolOverride(name);
+    return over ? `${label} (override: ${over.owner})` : label;
+}
+function describeToolCallBase(name, args) {
     const a = (args ?? {});
     const str = (v) => (typeof v === "string" ? v : "");
     const describePath = (p) => {
@@ -801,3 +938,95 @@ export const TOOL_ONE_LINERS = {
     todo_get: "Read the session task checklist.",
     todo_update: "Check off or edit one session task.",
 };
+// Extension-tool registration seam (ticket 02): the ExtensionAPI calls
+// this, never the custom store directly, so builtin collisions are rejected
+// here where the builtin names are known. Throws on bad shapes, builtin
+// collisions, and duplicate custom names — a loud error, never a silent
+// shadow. Returns an unregister function for hot-reload style removal.
+export function registerExtensionTool(def) {
+    validateExtensionToolDef(def);
+    if (TOOL_DEFINITIONS.some((t) => t.function.name === def.name)) {
+        throw new Error(`extension tool "${def.name}" collides with a builtin tool`);
+    }
+    const unregister = registerCustomTool(def);
+    const oneLiner = getCustomTool(def.name)?.oneLiner;
+    if (oneLiner)
+        TOOL_ONE_LINERS[def.name] = oneLiner;
+    let live = true;
+    return () => {
+        if (!live)
+            return;
+        live = false;
+        unregister();
+        delete TOOL_ONE_LINERS[def.name];
+    };
+}
+export function unregisterExtensionTool(name) {
+    const wasCustom = isCustomTool(name);
+    const removed = unregisterCustomTool(name);
+    // Only custom one-liners are ever added above: builtin entries stay intact.
+    if (wasCustom)
+        delete TOOL_ONE_LINERS[name];
+    return removed;
+}
+/** Test seam: drop every extension tool and its /tools one-liner. */
+export function clearExtensionTools() {
+    for (const name of customToolNames())
+        delete TOOL_ONE_LINERS[name];
+    clearCustomTools();
+}
+// Extension-tool override seam (ticket 06): the ExtensionAPI calls this,
+// never the override store directly, so non-builtin names are rejected here
+// where the builtin names are known. Shadowing is explicit and audited: the
+// override replaces the builtin everywhere (definitions carry an
+// `[overridden by extension "X"]` marker, the activity label a
+// `(override: X)` suffix, the /tools one-liner an `(override: X)` suffix),
+// and removing it restores the pristine builtin with no residue. Throws on
+// bad shapes, non-builtin names, and duplicate overrides — a loud error,
+// never a silent shadow. Returns an unregister function.
+export function registerExtensionToolOverride(def, owner = "(unknown)") {
+    validateExtensionToolOverrideDef(def);
+    if (!TOOL_DEFINITIONS.some((t) => t.function.name === def.name)) {
+        throw new Error(`extension tool override "${def.name}" is not a builtin tool (only builtins can be overridden)`);
+    }
+    const unregister = registerToolOverride(def, owner);
+    const pristineOneLiner = TOOL_ONE_LINERS[def.name];
+    if (pristineOneLiner !== undefined) {
+        TOOL_ONE_LINERS[def.name] = `${pristineOneLiner} (override: ${owner})`;
+    }
+    let live = true;
+    return () => {
+        if (!live)
+            return;
+        live = false;
+        unregister();
+        // Restore the pristine one-liner byte-identically (no residue): only the
+        // marked value we set above is ever replaced; a foreign value is left
+        // alone so a concurrent edit can never be clobbered.
+        if (pristineOneLiner !== undefined && TOOL_ONE_LINERS[def.name] === `${pristineOneLiner} (override: ${owner})`) {
+            TOOL_ONE_LINERS[def.name] = pristineOneLiner;
+        }
+    };
+}
+export function unregisterExtensionToolOverride(name) {
+    const over = getToolOverride(name);
+    const removed = unregisterToolOverride(name);
+    // Restore the pristine one-liner only when it still carries our marker.
+    if (over && removed && typeof TOOL_ONE_LINERS[name] === "string") {
+        const marker = ` (override: ${over.owner})`;
+        if (TOOL_ONE_LINERS[name].endsWith(marker)) {
+            TOOL_ONE_LINERS[name] = TOOL_ONE_LINERS[name].slice(0, -marker.length);
+        }
+    }
+    return removed;
+}
+// Scheduling hint for one tool name (ticket 06): the override's mode wins
+// for shadowed builtins, else the custom tool's mode, else undefined
+// (builtins carry no hint — the effect table drives them). "sequential"
+// forces the whole sibling batch one-at-a-time; "parallel" is advisory.
+export function toolExecutionMode(name) {
+    const over = getToolOverride(name);
+    if (over?.executionMode !== undefined)
+        return over.executionMode;
+    return getCustomTool(name)?.executionMode;
+}

package/dist/tools.js

@@ -8,6 +8,11 @@
 // executors, and the registry that owns names, validation, and dispatch).
 // This file is a pure barrel so every existing `from "./tools.js"` /
 // `"../src/tools.js"` import keeps working untouched.
+export * from "./tools/custom.js";
+export * from "./tools/compaction-hooks.js";
+export * from "./tools/intercept.js";
+export * from "./tools/overrides.js";
+export * from "./tools/provider-hooks.js";
 export * from "./tools/filesystem.js";
 export * from "./tools/fingerprints.js";
 export * from "./tools/dir-cache.js";
@@ -20,3 +25,42 @@ export * from "./tools/shared.js";
 export * from "./tools/shell.js";
 export * from "./tools/todo.js";
 export * from "./tools/web.js";
+export const UPDATE_GOAL_TOOL_DEFINITION = {
+    type: "function",
+    function: {
+        name: "update_goal",
+        description: "Report this goal turn's outcome (goal-scoped: only available during an active goal turn). " +
+            "WHEN to use: at the end of each goal turn — status \"continue\" with the next action, " +
+            "or \"complete\"/\"blocked\" with a reason. " +
+            "A \"complete\" lands only on genuinely finished work: verified checks and resolved todos. " +
+            "Checks you could not run go in \"unverified\" (recorded openly in the closing summary, never a gate). " +
+            "WHEN NOT to use: never outside a goal turn (it records nothing there); " +
+            "a turn with no report continues the goal.",
+        parameters: {
+            type: "object",
+            properties: {
+                status: {
+                    type: "string",
+                    enum: ["continue", "complete", "blocked"],
+                    description: "Turn outcome: \"continue\" (keep working), \"complete\" (goal done), \"blocked\" (cannot proceed).",
+                },
+                next: {
+                    type: "string",
+                    description: "Next action (only with status \"continue\"; omit otherwise).",
+                },
+                reason: {
+                    type: "string",
+                    description: "Why the goal is done or stuck (required with \"complete\"/\"blocked\"; omit otherwise).",
+                },
+                unverified: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Checks that could not be run (only with status \"complete\"; omit otherwise). " +
+                        "Recorded openly in the closing summary; at most 10 non-empty items of 200 characters each.",
+                },
+            },
+            required: ["status"],
+            additionalProperties: false,
+        },
+    },
+};

package/dist/ui/palette.js

@@ -9,7 +9,7 @@ import { Box, Text } from "ink";
 import { PickerMoreAbove, PickerMoreBelow, pickerWindow } from "./pickers.js";
 import { theme } from "./theme.js";
 export const PALETTE_WINDOW = 12;
-export const PALETTE_CATEGORY_ORDER = ["Model", "Session", "Tools", "Skills", "Flow", "Help"];
+export const PALETTE_CATEGORY_ORDER = ["Model", "Session", "Tools", "Skills", "Flow", "Extensions", "Help"];
 const PALETTE_CATEGORIES = {
     "/model": "Model",
     "/provider": "Model",