@axhub/acp 0.1.0

package/dist/lib/acp2aisdk/capability-cache.d.ts

@@ -0,0 +1,17 @@
+import type { AcpCapabilitySnapshot } from "./types";
+type StorageLike = Pick<Storage, "getItem" | "removeItem" | "setItem">;
+export declare const ACP_CAPABILITY_REFRESH_EVENT = "acp.capabilities.updated";
+export declare const safeLocalStorage: StorageLike;
+export declare function mergeAcpCapabilitySnapshots(previous?: AcpCapabilitySnapshot | null, next?: AcpCapabilitySnapshot | null): AcpCapabilitySnapshot | null;
+export declare function normalizeAcpCapabilitySnapshot(provider: string, snapshot?: unknown): AcpCapabilitySnapshot | null;
+export declare function getAcpCapabilityCacheKey(provider: string, projectPath?: string | null): string;
+export declare function readAcpCapabilityCache(provider: string, projectPath?: string | null, storage?: StorageLike): AcpCapabilitySnapshot | null;
+export declare function persistAcpCapabilityCache(provider: string, projectPath?: string | null, snapshot?: AcpCapabilitySnapshot | null, storage?: StorageLike): AcpCapabilitySnapshot | null;
+export declare function isAcpCapabilityCacheFresh(snapshot?: AcpCapabilitySnapshot | null, now?: number): boolean;
+export declare function shouldFetchAcpCapabilitySnapshot(snapshot?: AcpCapabilitySnapshot | null, { force, now }?: {
+    force?: boolean;
+    now?: number;
+}): boolean;
+export declare function mergeAndPersistAcpCapabilityCache(provider: string, projectPath?: string | null, snapshot?: AcpCapabilitySnapshot | null, storage?: StorageLike): AcpCapabilitySnapshot | null;
+export declare function hydrateAcpCapabilityCacheFromDefaults(provider: string, projectPath?: string | null, defaultSnapshot?: AcpCapabilitySnapshot | null, storage?: StorageLike): AcpCapabilitySnapshot | null;
+export {};

package/dist/lib/acp2aisdk/capability-cache.mjs

@@ -0,0 +1,259 @@
+import { ACP_CAPABILITY_CACHE_TTL_MS, getDefaultAcpCapabilitySnapshot, } from "./default-capabilities.mjs";
+const ACP_CAPABILITY_CACHE_PREFIX = "acp-capabilities:v1";
+const CAPABILITY_KEYS = ["model", "mode", "thought_level"];
+export const ACP_CAPABILITY_REFRESH_EVENT = "acp.capabilities.updated";
+export const safeLocalStorage = {
+    getItem(key) {
+        try {
+            return typeof window === "undefined"
+                ? null
+                : window.localStorage.getItem(key);
+        }
+        catch (_a) {
+            return null;
+        }
+    },
+    removeItem(key) {
+        try {
+            if (typeof window !== "undefined")
+                window.localStorage.removeItem(key);
+        }
+        catch (_a) { }
+    },
+    setItem(key, value) {
+        try {
+            if (typeof window !== "undefined")
+                window.localStorage.setItem(key, value);
+        }
+        catch (_a) { }
+    },
+};
+function normalizeText(value) {
+    return typeof value === "string" ? value.trim() : "";
+}
+function cloneJsonValue(value) {
+    if (value === undefined)
+        return value;
+    return JSON.parse(JSON.stringify(value));
+}
+function normalizeProvider(provider) {
+    return normalizeText(provider).toLowerCase() || "unknown";
+}
+function normalizeProjectPath(projectPath) {
+    return normalizeText(projectPath);
+}
+function normalizeCommand(command) {
+    var _a, _b;
+    if (!command || typeof command !== "object" || Array.isArray(command)) {
+        return null;
+    }
+    const record = command;
+    const name = normalizeText((_b = (_a = record.name) !== null && _a !== void 0 ? _a : record.command) !== null && _b !== void 0 ? _b : record.id).replace(/^\/+/, "");
+    if (!name)
+        return null;
+    return {
+        name,
+        description: normalizeText(record.description),
+        input: record.input,
+        source: "acp",
+    };
+}
+function normalizeCommands(value) {
+    return (Array.isArray(value) ? value : [])
+        .map(normalizeCommand)
+        .filter((command) => Boolean(command));
+}
+function mergeCommands(previousCommands, nextCommands) {
+    const merged = [];
+    const seen = new Set();
+    for (const command of [
+        ...normalizeCommands(nextCommands),
+        ...normalizeCommands(previousCommands),
+    ]) {
+        const key = command.name.replace(/^\/+/, "").toLowerCase();
+        if (!key || seen.has(key))
+            continue;
+        seen.add(key);
+        merged.push(command);
+    }
+    return merged;
+}
+function normalizeOption(option, index = 0) {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    if (option == null)
+        return null;
+    if (typeof option === "string" ||
+        typeof option === "number" ||
+        typeof option === "boolean") {
+        const value = String(option).trim();
+        return value
+            ? { value, label: value, description: "", order: index }
+            : null;
+    }
+    if (typeof option !== "object" || Array.isArray(option))
+        return null;
+    const record = option;
+    const value = normalizeText((_e = (_d = (_c = (_b = (_a = record.value) !== null && _a !== void 0 ? _a : record.id) !== null && _b !== void 0 ? _b : record.modeId) !== null && _c !== void 0 ? _c : record.const) !== null && _d !== void 0 ? _d : (Array.isArray(record.enum) ? record.enum[0] : undefined)) !== null && _e !== void 0 ? _e : record.name);
+    if (!value)
+        return null;
+    return {
+        value,
+        label: normalizeText((_h = (_g = (_f = record.label) !== null && _f !== void 0 ? _f : record.title) !== null && _g !== void 0 ? _g : record.name) !== null && _h !== void 0 ? _h : record.description) || value,
+        description: normalizeText(record.description),
+        order: Number.isInteger(record.order) ? Number(record.order) : index,
+    };
+}
+function dedupeOptions(options) {
+    const seen = new Set();
+    return options.filter((option) => {
+        if (!option.value || seen.has(option.value))
+            return false;
+        seen.add(option.value);
+        return true;
+    });
+}
+function normalizeCapability(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return null;
+    const record = value;
+    const key = normalizeText(record.key);
+    if (key !== "model" && key !== "mode" && key !== "thought_level")
+        return null;
+    const options = dedupeOptions((Array.isArray(record.options) ? record.options : [])
+        .map(normalizeOption)
+        .filter((option) => Boolean(option)));
+    return {
+        key,
+        currentValue: normalizeText(record.currentValue) || null,
+        options,
+        configId: normalizeText(record.configId) || key,
+        configKey: normalizeText(record.configKey) || normalizeText(record.configId) || key,
+        source: record.source === "session" ||
+            record.source === "config-option" ||
+            record.source === "fallback"
+            ? record.source
+            : "fallback",
+    };
+}
+function mergeCapability(previous, next) {
+    if (!previous)
+        return next !== null && next !== void 0 ? next : null;
+    if (!next)
+        return previous;
+    return Object.assign(Object.assign(Object.assign({}, previous), next), { options: next.options.length
+            ? dedupeOptions(next.options)
+            : previous.options, currentValue: next.currentValue !== undefined
+            ? next.currentValue
+            : previous.currentValue });
+}
+export function mergeAcpCapabilitySnapshots(previous, next) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+    if (!previous)
+        return next !== null && next !== void 0 ? next : null;
+    if (!next)
+        return previous;
+    const capabilities = Object.assign({}, ((_a = previous.capabilities) !== null && _a !== void 0 ? _a : {}));
+    for (const key of CAPABILITY_KEYS) {
+        const merged = mergeCapability(capabilities[key], (_b = next.capabilities) === null || _b === void 0 ? void 0 : _b[key]);
+        if (merged)
+            capabilities[key] = merged;
+    }
+    return Object.assign(Object.assign(Object.assign({}, previous), next), { capabilities, metadata: Object.assign(Object.assign(Object.assign({}, ((_c = previous.metadata) !== null && _c !== void 0 ? _c : { availableCommands: [] })), ((_d = next.metadata) !== null && _d !== void 0 ? _d : { availableCommands: [] })), { tokenUsage: (_h = (_f = (_e = next.metadata) === null || _e === void 0 ? void 0 : _e.tokenUsage) !== null && _f !== void 0 ? _f : (_g = previous.metadata) === null || _g === void 0 ? void 0 : _g.tokenUsage) !== null && _h !== void 0 ? _h : null, availableCommands: mergeCommands((_j = previous.metadata) === null || _j === void 0 ? void 0 : _j.availableCommands, (_k = next.metadata) === null || _k === void 0 ? void 0 : _k.availableCommands) }) });
+}
+export function normalizeAcpCapabilitySnapshot(provider, snapshot) {
+    var _a;
+    if (!snapshot || typeof snapshot !== "object" || Array.isArray(snapshot)) {
+        return null;
+    }
+    const record = snapshot;
+    const capabilities = {};
+    const rawCapabilities = record.capabilities && typeof record.capabilities === "object"
+        ? record.capabilities
+        : {};
+    for (const key of CAPABILITY_KEYS) {
+        const capability = normalizeCapability(rawCapabilities[key]);
+        if (capability)
+            capabilities[key] = capability;
+    }
+    const metadata = record.metadata && typeof record.metadata === "object"
+        ? record.metadata
+        : {};
+    return Object.assign(Object.assign({}, cloneJsonValue(record)), { provider: normalizeProvider(record.provider || provider), sessionId: normalizeText(record.sessionId) || null, source: normalizeText(record.source) || null, updatedAt: normalizeText(record.updatedAt) || new Date().toISOString(), ttl: Number.isFinite(Number(record.ttl)) && Number(record.ttl) > 0
+            ? Number(record.ttl)
+            : ACP_CAPABILITY_CACHE_TTL_MS, agentVersion: normalizeText(record.agentVersion) || null, capabilities, metadata: Object.assign(Object.assign({}, metadata), { tokenUsage: (_a = metadata.tokenUsage) !== null && _a !== void 0 ? _a : null, availableCommands: normalizeCommands(metadata.availableCommands) }) });
+}
+export function getAcpCapabilityCacheKey(provider, projectPath) {
+    const normalizedProvider = encodeURIComponent(normalizeProvider(provider));
+    const normalizedProjectPath = normalizeProjectPath(projectPath);
+    return `${ACP_CAPABILITY_CACHE_PREFIX}:${normalizedProvider}:${normalizedProjectPath ? encodeURIComponent(normalizedProjectPath) : "global"}`;
+}
+export function readAcpCapabilityCache(provider, projectPath, storage = safeLocalStorage) {
+    const key = getAcpCapabilityCacheKey(provider, projectPath);
+    const raw = storage.getItem(key);
+    if (!raw)
+        return null;
+    try {
+        return normalizeAcpCapabilitySnapshot(provider, JSON.parse(raw));
+    }
+    catch (_a) {
+        storage.removeItem(key);
+        return null;
+    }
+}
+export function persistAcpCapabilityCache(provider, projectPath, snapshot, storage = safeLocalStorage) {
+    const normalized = normalizeAcpCapabilitySnapshot(provider, snapshot);
+    const key = getAcpCapabilityCacheKey(provider, projectPath);
+    if (!normalized) {
+        storage.removeItem(key);
+        return null;
+    }
+    storage.setItem(key, JSON.stringify(normalized));
+    return normalized;
+}
+export function isAcpCapabilityCacheFresh(snapshot, now = Date.now()) {
+    if (!snapshot)
+        return false;
+    const updatedAtMs = Date.parse(snapshot.updatedAt || "");
+    if (!Number.isFinite(updatedAtMs))
+        return false;
+    const ttl = Number(snapshot.ttl || ACP_CAPABILITY_CACHE_TTL_MS);
+    return Number.isFinite(ttl) && ttl > 0 && now - updatedAtMs < ttl;
+}
+export function shouldFetchAcpCapabilitySnapshot(snapshot, { force = false, now = Date.now() } = {}) {
+    return force || !isAcpCapabilityCacheFresh(snapshot, now);
+}
+export function mergeAndPersistAcpCapabilityCache(provider, projectPath, snapshot, storage = safeLocalStorage) {
+    const previous = readAcpCapabilityCache(provider, projectPath, storage);
+    const next = normalizeAcpCapabilitySnapshot(provider, snapshot);
+    return persistAcpCapabilityCache(provider, projectPath, mergeAcpCapabilitySnapshots(previous, next), storage);
+}
+function parseSnapshotTimestamp(snapshot) {
+    const timestamp = Date.parse((snapshot === null || snapshot === void 0 ? void 0 : snapshot.updatedAt) || "");
+    return Number.isFinite(timestamp) ? timestamp : 0;
+}
+function removeFallbackCapabilities(previous) {
+    var _a, _b;
+    const capabilities = Object.assign({}, ((_a = previous.capabilities) !== null && _a !== void 0 ? _a : {}));
+    for (const key of CAPABILITY_KEYS) {
+        if (((_b = capabilities[key]) === null || _b === void 0 ? void 0 : _b.source) === "fallback") {
+            delete capabilities[key];
+        }
+    }
+    return Object.assign(Object.assign({}, previous), { capabilities });
+}
+export function hydrateAcpCapabilityCacheFromDefaults(provider, projectPath, defaultSnapshot = getDefaultAcpCapabilitySnapshot(provider), storage = safeLocalStorage) {
+    const normalizedDefault = normalizeAcpCapabilitySnapshot(provider, defaultSnapshot);
+    if (!normalizedDefault) {
+        return readAcpCapabilityCache(provider, projectPath, storage);
+    }
+    const previous = readAcpCapabilityCache(provider, projectPath, storage);
+    if (!previous) {
+        return persistAcpCapabilityCache(provider, projectPath, normalizedDefault, storage);
+    }
+    const defaultIsNewer = parseSnapshotTimestamp(normalizedDefault) >=
+        parseSnapshotTimestamp(previous);
+    const merged = defaultIsNewer
+        ? mergeAcpCapabilitySnapshots(normalizedDefault, removeFallbackCapabilities(previous))
+        : mergeAcpCapabilitySnapshots(normalizedDefault, previous);
+    return persistAcpCapabilityCache(provider, projectPath, merged, storage);
+}

package/dist/lib/acp2aisdk/client-context.d.ts

@@ -0,0 +1,38 @@
+import { type PropsWithChildren } from "react";
+import type { AcpBuiltinToolSettings, AcpProviderKey } from "./";
+import { type ContextBundleV2, type ContextItem, type ContextItemKind, type ContextOperationResult } from "./context";
+type BuiltinToolSettingsUpdater = unknown | ((current: unknown) => unknown);
+export type AcpUiRuntimeContext = {
+    provider: AcpProviderKey;
+    model: string | null;
+    modeId: string | null;
+    thoughtLevel: string | null;
+    explicitModel: string | null;
+    explicitModeId: string | null;
+    explicitThoughtLevel: string | null;
+    permissionMode: string;
+    workspacePath: string | null;
+    builtinToolSettings: AcpBuiltinToolSettings;
+    contextBundle: ContextBundleV2;
+    setProvider: (value: string | null) => void;
+    setModel: (value: string | null) => void;
+    setModeId: (value: string | null) => void;
+    setThoughtLevel: (value: string | null) => void;
+    setBuiltinToolSettings: (toolId: string, value: BuiltinToolSettingsUpdater) => void;
+    syncModel: (value: string | null) => void;
+    syncModeId: (value: string | null) => void;
+    syncThoughtLevel: (value: string | null) => void;
+    addContextItems: (items: ContextItem[]) => ContextOperationResult;
+    removeContextItems: (ids: string[]) => ContextOperationResult;
+    replaceContextItems: (items: ContextItem[]) => ContextOperationResult;
+    clearContextItems: (kinds?: ContextItemKind[]) => ContextOperationResult;
+    getContextBundle: (kinds?: ContextItemKind[]) => ContextBundleV2;
+    consumeContextBundle: () => ContextBundleV2 | null;
+};
+type AcpUiProviderProps = PropsWithChildren<{
+    workspacePath?: string | null;
+    defaultProvider?: string | null;
+}>;
+export declare function AcpUiProvider({ children, workspacePath, defaultProvider, }: AcpUiProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function useAcpUiRuntimeContext(): AcpUiRuntimeContext;
+export {};

package/dist/lib/acp2aisdk/client-context.mjs

@@ -0,0 +1,247 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useCallback, useContext, useEffect, useMemo, useRef, useState, } from "react";
+import { createContextBundle, filterContextBundle, } from "./context.mjs";
+import { normalizeAcpProvider } from "./provider-registry.mjs";
+import { readStoredBuiltinToolSettings, storeBuiltinToolSettings, updateClientBuiltinToolSettings, } from "../../tools/client-registry.mjs";
+const DEFAULT_PROVIDER = "codex";
+const DEFAULT_PERMISSION_MODE = "bypassPermissions";
+const AcpUiContext = createContext(null);
+function stableStringify(value) {
+    if (Array.isArray(value)) {
+        return `[${value.map((entry) => stableStringify(entry)).join(",")}]`;
+    }
+    if (value && typeof value === "object") {
+        const record = value;
+        return `{${Object.keys(record)
+            .sort()
+            .map((key) => `${JSON.stringify(key)}:${stableStringify(record[key])}`)
+            .join(",")}}`;
+    }
+    return JSON.stringify(value);
+}
+function hashString(value) {
+    let hash = 2166136261;
+    for (let index = 0; index < value.length; index++) {
+        hash ^= value.charCodeAt(index);
+        hash = Math.imul(hash, 16777619);
+    }
+    return (hash >>> 0).toString(36);
+}
+function contextItemKey(item) {
+    const baseItem = Object.assign({}, item);
+    delete baseItem.id;
+    return `${item.kind}:${hashString(stableStringify(baseItem))}`;
+}
+function withContextItemIds(items) {
+    return items.map((item) => (Object.assign(Object.assign({}, item), { id: typeof item.id === "string" && item.id.trim()
+            ? item.id.trim()
+            : contextItemKey(item) })));
+}
+function createChangedBundle(items) {
+    return createContextBundle(items, new Date().toISOString());
+}
+function getContextItemIds(items) {
+    return items.map((item) => item.id).filter((id) => Boolean(id));
+}
+function emitContextChanged(context, change) {
+    if (typeof window === "undefined")
+        return;
+    window.dispatchEvent(new CustomEvent("acp.context.local-change", {
+        detail: { context, change },
+    }));
+}
+export function AcpUiProvider({ children, workspacePath, defaultProvider, }) {
+    const [provider, setProviderState] = useState(() => normalizeAcpProvider(defaultProvider !== null && defaultProvider !== void 0 ? defaultProvider : DEFAULT_PROVIDER));
+    const [model, setModelState] = useState(null);
+    const [modeId, setModeIdState] = useState(null);
+    const [thoughtLevel, setThoughtLevelState] = useState(null);
+    const [explicitModel, setExplicitModelState] = useState(null);
+    const [explicitModeId, setExplicitModeIdState] = useState(null);
+    const [explicitThoughtLevel, setExplicitThoughtLevelState] = useState(null);
+    const [builtinToolSettings, setBuiltinToolSettingsState] = useState({});
+    const [contextBundle, setContextBundleState] = useState(() => createContextBundle());
+    const contextBundleRef = useRef(contextBundle);
+    const setContextBundle = useCallback((next) => {
+        contextBundleRef.current = next;
+        setContextBundleState(next);
+    }, []);
+    useEffect(() => {
+        setBuiltinToolSettingsState(readStoredBuiltinToolSettings());
+    }, []);
+    const normalize = useCallback((value) => {
+        const normalized = String(value !== null && value !== void 0 ? value : "").trim();
+        return normalized || null;
+    }, []);
+    const setProvider = useCallback((next) => {
+        const normalizedProvider = normalizeAcpProvider(next !== null && next !== void 0 ? next : DEFAULT_PROVIDER);
+        setProviderState((currentProvider) => {
+            if (currentProvider === normalizedProvider)
+                return currentProvider;
+            setModelState(null);
+            setModeIdState(null);
+            setThoughtLevelState(null);
+            setExplicitModelState(null);
+            setExplicitModeIdState(null);
+            setExplicitThoughtLevelState(null);
+            return normalizedProvider;
+        });
+    }, []);
+    const setModel = useCallback((next) => {
+        const normalized = normalize(next);
+        setModelState(normalized);
+        setExplicitModelState(normalized);
+    }, [normalize]);
+    const setModeId = useCallback((next) => {
+        const normalized = normalize(next);
+        setModeIdState(normalized);
+        setExplicitModeIdState(normalized);
+    }, [normalize]);
+    const setThoughtLevel = useCallback((next) => {
+        const normalized = normalize(next);
+        setThoughtLevelState(normalized);
+        setExplicitThoughtLevelState(normalized);
+    }, [normalize]);
+    const setBuiltinToolSettings = useCallback((toolId, next) => {
+        setBuiltinToolSettingsState((current) => {
+            const updated = updateClientBuiltinToolSettings(current, toolId, next);
+            storeBuiltinToolSettings(updated);
+            return updated;
+        });
+    }, []);
+    const syncModel = useCallback((next) => setModelState(normalize(next)), [normalize]);
+    const syncModeId = useCallback((next) => setModeIdState(normalize(next)), [normalize]);
+    const syncThoughtLevel = useCallback((next) => setThoughtLevelState(normalize(next)), [normalize]);
+    const addContextItems = useCallback((items) => {
+        const normalizedItems = withContextItemIds(items);
+        const current = contextBundleRef.current;
+        const itemById = new Map(current.items.map((item) => [item.id, item]));
+        for (const item of normalizedItems) {
+            itemById.set(item.id, item);
+        }
+        const next = createChangedBundle([...itemById.values()]);
+        const change = {
+            operation: "add",
+            ids: getContextItemIds(normalizedItems),
+            items: normalizedItems,
+        };
+        setContextBundle(next);
+        emitContextChanged(next, change);
+        return { context: next, change };
+    }, [setContextBundle]);
+    const removeContextItems = useCallback((ids) => {
+        const normalizedIds = ids.map((id) => id.trim()).filter(Boolean);
+        const idSet = new Set(normalizedIds);
+        const next = createChangedBundle(contextBundleRef.current.items.filter((item) => { var _a; return !idSet.has((_a = item.id) !== null && _a !== void 0 ? _a : ""); }));
+        const change = {
+            operation: "remove",
+            ids: normalizedIds,
+        };
+        setContextBundle(next);
+        emitContextChanged(next, change);
+        return { context: next, change };
+    }, [setContextBundle]);
+    const replaceContextItems = useCallback((items) => {
+        const normalizedItems = withContextItemIds(items);
+        const next = createChangedBundle(normalizedItems);
+        const change = {
+            operation: "replace",
+            ids: getContextItemIds(normalizedItems),
+            items: normalizedItems,
+        };
+        setContextBundle(next);
+        emitContextChanged(next, change);
+        return { context: next, change };
+    }, [setContextBundle]);
+    const clearContextItems = useCallback((kinds) => {
+        const kindSet = kinds ? new Set(kinds) : null;
+        const next = createChangedBundle(kindSet
+            ? contextBundleRef.current.items.filter((item) => !kindSet.has(item.kind))
+            : []);
+        const change = {
+            operation: "clear",
+            kinds,
+        };
+        setContextBundle(next);
+        emitContextChanged(next, change);
+        return { context: next, change };
+    }, [setContextBundle]);
+    const getContextBundle = useCallback((kinds) => {
+        return filterContextBundle(contextBundleRef.current, kinds);
+    }, []);
+    const consumeContextBundle = useCallback(() => {
+        const current = contextBundleRef.current;
+        if (current.items.length === 0)
+            return null;
+        const consumed = current;
+        const next = createChangedBundle([]);
+        setContextBundle(next);
+        emitContextChanged(next, {
+            operation: "consume",
+            ids: getContextItemIds(consumed.items),
+            items: consumed.items,
+        });
+        return consumed;
+    }, [setContextBundle]);
+    const value = useMemo(() => ({
+        provider,
+        model,
+        modeId,
+        thoughtLevel,
+        explicitModel,
+        explicitModeId,
+        explicitThoughtLevel,
+        permissionMode: DEFAULT_PERMISSION_MODE,
+        workspacePath: normalize(workspacePath !== null && workspacePath !== void 0 ? workspacePath : null),
+        builtinToolSettings,
+        contextBundle,
+        setProvider,
+        setModel,
+        setModeId,
+        setThoughtLevel,
+        setBuiltinToolSettings,
+        syncModel,
+        syncModeId,
+        syncThoughtLevel,
+        addContextItems,
+        removeContextItems,
+        replaceContextItems,
+        clearContextItems,
+        getContextBundle,
+        consumeContextBundle,
+    }), [
+        addContextItems,
+        clearContextItems,
+        consumeContextBundle,
+        contextBundle,
+        builtinToolSettings,
+        explicitModeId,
+        explicitModel,
+        explicitThoughtLevel,
+        getContextBundle,
+        model,
+        modeId,
+        normalize,
+        provider,
+        removeContextItems,
+        replaceContextItems,
+        setModeId,
+        setModel,
+        setProvider,
+        setBuiltinToolSettings,
+        syncModeId,
+        syncModel,
+        syncThoughtLevel,
+        setThoughtLevel,
+        thoughtLevel,
+        workspacePath,
+    ]);
+    return (_jsx(AcpUiContext.Provider, { value: value, children: children }));
+}
+export function useAcpUiRuntimeContext() {
+    const context = useContext(AcpUiContext);
+    if (!context) {
+        throw new Error("useAcpUiRuntimeContext must be used inside AcpUiProvider");
+    }
+    return context;
+}

package/dist/lib/acp2aisdk/commands.d.ts

@@ -0,0 +1,11 @@
+export type AcpUiCommand = {
+    name: string;
+    description: string;
+    namespace: "skill" | "acp";
+    source: "skill" | "acp";
+    path?: string;
+    scope?: "user" | "system" | "project";
+};
+export declare function listAcpUiCommands({ workspacePath, }?: {
+    workspacePath?: string | null;
+}): Promise<AcpUiCommand[]>;