@axhub/acp 0.1.0

package/dist/public-api/runtime.mjs

@@ -0,0 +1,7 @@
+"use client";
+export { ACP_CAPABILITY_REFRESH_EVENT, hydrateAcpCapabilityCacheFromDefaults, mergeAcpCapabilitySnapshots, normalizeAcpCapabilitySnapshot, readAcpCapabilityCache, } from "../lib/acp2aisdk/capability-cache.mjs";
+export { AcpUiProvider, useAcpUiRuntimeContext, } from "../lib/acp2aisdk/client-context.mjs";
+export { createContextBundle, filterContextBundle, formatDynamicContextPrompt, hasContextItems, isContextItemKind, } from "../lib/acp2aisdk/context.mjs";
+export { ACP_PROVIDER_KEYS, ACP_PROVIDER_REGISTRY, getAcpProviderDefaultModeId, isAcpProviderKey, normalizeAcpProvider, } from "../lib/acp2aisdk/provider-registry.mjs";
+export { acpApiClient, acpApiEndpoints, configureAcpUiRuntime, readAcpUiRuntimeConfig, } from "../lib/api/client.mjs";
+export { useConversationChatRuntime } from "../lib/conversations/client-adapter.mjs";

package/dist/public-api/server.d.ts

@@ -0,0 +1,5 @@
+export { cleanupAcpSession, getAcpSessionMetadata, listAcpSessionMetadata, streamAcpChat, } from "../lib/acp2aisdk";
+export { buildAcpCapabilitySnapshot } from "../lib/acp2aisdk/capabilities";
+export { ACP_PROVIDER_ALIASES, ACP_PROVIDER_DEFAULT_MODE_IDS, ACP_PROVIDER_KEYS, ACP_PROVIDER_REGISTRY, getAcpProviderDefaultModeId, isAcpProviderKey, normalizeAcpProvider, readProviderOverridesFromEnv, resolveAcpProviderConfig, } from "../lib/acp2aisdk/provider-registry";
+export { createAcpSessionKey, createInitialMetadata, DEFAULT_PERMISSION_MODE, DEFAULT_THREAD_ID, getDefaultWorkspacePath, getGlobalAcpSessionStore, normalizeThreadId, normalizeWorkspacePath, SESSION_IDLE_TTL_MS, } from "../lib/acp2aisdk/session-store";
+export type { AcpCapability, AcpCapabilityOption, AcpCapabilitySnapshot, AcpChatRequest, AcpCleanupResult, AcpMcpServer, AcpPermissionMode, AcpProviderKey, AcpProviderRegistryEntry, AcpRunState, AcpRuntimeMetadata, AcpSessionLookupRequest, AcpStreamChatResult, } from "../lib/acp2aisdk/types";

package/dist/public-api/server.mjs

@@ -0,0 +1,4 @@
+export { cleanupAcpSession, getAcpSessionMetadata, listAcpSessionMetadata, streamAcpChat, } from "../lib/acp2aisdk/index.mjs";
+export { buildAcpCapabilitySnapshot } from "../lib/acp2aisdk/capabilities.mjs";
+export { ACP_PROVIDER_ALIASES, ACP_PROVIDER_DEFAULT_MODE_IDS, ACP_PROVIDER_KEYS, ACP_PROVIDER_REGISTRY, getAcpProviderDefaultModeId, isAcpProviderKey, normalizeAcpProvider, readProviderOverridesFromEnv, resolveAcpProviderConfig, } from "../lib/acp2aisdk/provider-registry.mjs";
+export { createAcpSessionKey, createInitialMetadata, DEFAULT_PERMISSION_MODE, DEFAULT_THREAD_ID, getDefaultWorkspacePath, getGlobalAcpSessionStore, normalizeThreadId, normalizeWorkspacePath, SESSION_IDLE_TTL_MS, } from "../lib/acp2aisdk/session-store.mjs";

package/dist/public-api/styles.css

@@ -0,0 +1 @@
+@import "../app/globals.css";

package/dist/public-api/ui.d.ts

@@ -0,0 +1,13 @@
+export { AcpCommandMenu, AcpCommandTriggerButton, } from "../components/assistant-ui/acp-command-menu";
+export { AcpComposerSelectors, AcpHeaderContext, } from "../components/assistant-ui/acp-selectors";
+export { ThreadAddonHost, ThreadAddonProvider, ThreadAddonToolbar, } from "../components/assistant-ui/addons/host";
+export type { ThreadAddon, ThreadAddonPanelLocation, ThreadAddonPanelProps, } from "../components/assistant-ui/addons/types";
+export { ComposerAddAttachment, type ComposerAddAttachmentProps, ComposerAttachments, UserMessageAttachments, } from "../components/assistant-ui/attachment";
+export { File, FileDownload, FileIconDisplay, FileName, FileRoot, FileSize, fileVariants, formatFileSize, getBase64Size, getMimeTypeIcon, } from "../components/assistant-ui/file";
+export { Image, ImageActions, ImageContentFilterError, ImageFilename, ImageGenerating, ImageMessage, ImagePreview, ImageRoot, ImageZoom, imageVariants, } from "../components/assistant-ui/image";
+export { MarkdownText } from "../components/assistant-ui/markdown-text";
+export { AssistantActionBar, AssistantMessage, BranchPicker, Composer, ComposerAction, type ComposerActionProps, type ComposerProps, ContextChips, EditComposer, MessageError, MessageList, Thread, ThreadEmptyState, ThreadHistoryEmpty, ThreadHistoryLoading, ThreadMessage, type ThreadProps, ThreadScrollToBottom, ThreadSuggestionItem, ThreadSuggestions, ThreadWelcome, UserActionBar, UserMessage, } from "../components/assistant-ui/thread";
+export { ThreadList } from "../components/assistant-ui/thread-list";
+export { ThreadListSidebar } from "../components/assistant-ui/threadlist-sidebar";
+export { ToolFallback, ToolFallbackArgs, ToolFallbackContent, ToolFallbackError, ToolFallbackResult, ToolFallbackRoot, ToolFallbackTrigger, } from "../components/assistant-ui/tool-fallback";
+export { TooltipIconButton, type TooltipIconButtonProps, } from "../components/assistant-ui/tooltip-icon-button";

package/dist/public-api/ui.mjs

@@ -0,0 +1,13 @@
+"use client";
+export { AcpCommandMenu, AcpCommandTriggerButton, } from "../components/assistant-ui/acp-command-menu.mjs";
+export { AcpComposerSelectors, AcpHeaderContext, } from "../components/assistant-ui/acp-selectors.mjs";
+export { ThreadAddonHost, ThreadAddonProvider, ThreadAddonToolbar, } from "../components/assistant-ui/addons/host.mjs";
+export { ComposerAddAttachment, ComposerAttachments, UserMessageAttachments, } from "../components/assistant-ui/attachment.mjs";
+export { File, FileDownload, FileIconDisplay, FileName, FileRoot, FileSize, fileVariants, formatFileSize, getBase64Size, getMimeTypeIcon, } from "../components/assistant-ui/file.mjs";
+export { Image, ImageActions, ImageContentFilterError, ImageFilename, ImageGenerating, ImageMessage, ImagePreview, ImageRoot, ImageZoom, imageVariants, } from "../components/assistant-ui/image.mjs";
+export { MarkdownText } from "../components/assistant-ui/markdown-text.mjs";
+export { AssistantActionBar, AssistantMessage, BranchPicker, Composer, ComposerAction, ContextChips, EditComposer, MessageError, MessageList, Thread, ThreadEmptyState, ThreadHistoryEmpty, ThreadHistoryLoading, ThreadMessage, ThreadScrollToBottom, ThreadSuggestionItem, ThreadSuggestions, ThreadWelcome, UserActionBar, UserMessage, } from "../components/assistant-ui/thread.mjs";
+export { ThreadList } from "../components/assistant-ui/thread-list.mjs";
+export { ThreadListSidebar } from "../components/assistant-ui/threadlist-sidebar.mjs";
+export { ToolFallback, ToolFallbackArgs, ToolFallbackContent, ToolFallbackError, ToolFallbackResult, ToolFallbackRoot, ToolFallbackTrigger, } from "../components/assistant-ui/tool-fallback.mjs";
+export { TooltipIconButton, } from "../components/assistant-ui/tooltip-icon-button.mjs";

package/dist/tools/client-registry.d.ts

@@ -0,0 +1,9 @@
+import type { AcpBuiltinToolSettings } from "../lib/acp2aisdk/types";
+type BuiltinToolSettingsUpdater = unknown | ((current: unknown) => unknown);
+export declare function getDefaultBuiltinToolIds(): string[];
+export declare function getEnabledBuiltinToolIds(settings: unknown): string[];
+export declare function normalizeClientBuiltinToolSettings(value: unknown): AcpBuiltinToolSettings;
+export declare function readStoredBuiltinToolSettings(): AcpBuiltinToolSettings;
+export declare function storeBuiltinToolSettings(settings: AcpBuiltinToolSettings): void;
+export declare function updateClientBuiltinToolSettings(current: AcpBuiltinToolSettings, toolId: string, updater: BuiltinToolSettingsUpdater): AcpBuiltinToolSettings;
+export {};

package/dist/tools/client-registry.mjs

@@ -0,0 +1,70 @@
+import { imageGenerationClientTool } from "./image-generation/client.mjs";
+import { userChoiceClientTool } from "./user-choice/client.mjs";
+const BUILTIN_TOOL_SETTINGS_STORAGE_KEY = "acp-ui-builtin-tool-settings";
+const CLIENT_BUILTIN_TOOLS = [
+    imageGenerationClientTool,
+    userChoiceClientTool,
+];
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function readJsonStorage(key) {
+    if (typeof window === "undefined")
+        return null;
+    try {
+        const stored = window.localStorage.getItem(key);
+        return stored ? JSON.parse(stored) : null;
+    }
+    catch (_a) {
+        return null;
+    }
+}
+function writeJsonStorage(key, value) {
+    if (typeof window === "undefined")
+        return;
+    window.localStorage.setItem(key, JSON.stringify(value));
+}
+export function getDefaultBuiltinToolIds() {
+    return CLIENT_BUILTIN_TOOLS.map((tool) => tool.id);
+}
+export function getEnabledBuiltinToolIds(settings) {
+    const normalized = normalizeClientBuiltinToolSettings(settings);
+    return CLIENT_BUILTIN_TOOLS.filter((tool) => { var _a, _b; return (_b = (_a = tool.isEnabled) === null || _a === void 0 ? void 0 : _a.call(tool, normalized[tool.id])) !== null && _b !== void 0 ? _b : true; }).map((tool) => tool.id);
+}
+export function normalizeClientBuiltinToolSettings(value) {
+    const record = isRecord(value) ? value : {};
+    const settings = {};
+    for (const tool of CLIENT_BUILTIN_TOOLS) {
+        settings[tool.id] = tool.normalizeSettings(tool.id in record ? record[tool.id] : tool.defaultSettings);
+    }
+    return settings;
+}
+export function readStoredBuiltinToolSettings() {
+    const stored = readJsonStorage(BUILTIN_TOOL_SETTINGS_STORAGE_KEY);
+    const base = isRecord(stored) ? Object.assign({}, stored) : {};
+    for (const tool of CLIENT_BUILTIN_TOOLS) {
+        if (tool.id in base || !tool.legacyStorageKey)
+            continue;
+        const legacySettings = readJsonStorage(tool.legacyStorageKey);
+        if (legacySettings)
+            base[tool.id] = legacySettings;
+    }
+    return normalizeClientBuiltinToolSettings(base);
+}
+export function storeBuiltinToolSettings(settings) {
+    const normalized = normalizeClientBuiltinToolSettings(settings);
+    writeJsonStorage(BUILTIN_TOOL_SETTINGS_STORAGE_KEY, normalized);
+    for (const tool of CLIENT_BUILTIN_TOOLS) {
+        if (!tool.legacyStorageKey)
+            continue;
+        writeJsonStorage(tool.legacyStorageKey, normalized[tool.id]);
+    }
+}
+export function updateClientBuiltinToolSettings(current, toolId, updater) {
+    const rawCurrent = current[toolId];
+    const rawNext = typeof updater === "function"
+        ? updater(rawCurrent)
+        : updater;
+    const next = normalizeClientBuiltinToolSettings(Object.assign(Object.assign({}, current), { [toolId]: rawNext }));
+    return next;
+}

package/dist/tools/image-generation/client.d.ts

@@ -0,0 +1,18 @@
+import { type ImageGenerationRuntimeSettings } from "./shared";
+export type ImageGenerationToolSettings = ImageGenerationRuntimeSettings & {
+    enabled: boolean;
+    baseUrl: string;
+    apiKey: string;
+    model: string;
+    preservePrompt: boolean;
+};
+export declare const IMAGE_GENERATION_TOOL_SETTINGS_STORAGE_KEY = "acp-ui-image-generation-tool-settings";
+export declare const DEFAULT_IMAGE_GENERATION_TOOL_SETTINGS: ImageGenerationToolSettings;
+export declare function normalizeImageGenerationToolSettings(value: unknown): ImageGenerationToolSettings;
+export declare const imageGenerationClientTool: {
+    id: string;
+    defaultSettings: ImageGenerationToolSettings;
+    legacyStorageKey: string;
+    normalizeSettings: typeof normalizeImageGenerationToolSettings;
+    isEnabled(settings: unknown): boolean;
+};

package/dist/tools/image-generation/client.mjs

@@ -0,0 +1,31 @@
+import { IMAGE_GENERATION_TOOL_ID, isRecord, } from "./shared.mjs";
+export const IMAGE_GENERATION_TOOL_SETTINGS_STORAGE_KEY = "acp-ui-image-generation-tool-settings";
+export const DEFAULT_IMAGE_GENERATION_TOOL_SETTINGS = {
+    enabled: true,
+    baseUrl: "",
+    apiKey: "",
+    model: "",
+    preservePrompt: true,
+};
+export function normalizeImageGenerationToolSettings(value) {
+    if (!isRecord(value))
+        return DEFAULT_IMAGE_GENERATION_TOOL_SETTINGS;
+    const readString = (key) => typeof value[key] === "string" ? value[key].trim() : "";
+    return {
+        enabled: value.enabled !== false,
+        baseUrl: readString("baseUrl"),
+        apiKey: readString("apiKey"),
+        model: readString("model"),
+        savePathPattern: readString("savePathPattern") || undefined,
+        preservePrompt: typeof value.preservePrompt === "boolean" ? value.preservePrompt : true,
+    };
+}
+export const imageGenerationClientTool = {
+    id: IMAGE_GENERATION_TOOL_ID,
+    defaultSettings: DEFAULT_IMAGE_GENERATION_TOOL_SETTINGS,
+    legacyStorageKey: IMAGE_GENERATION_TOOL_SETTINGS_STORAGE_KEY,
+    normalizeSettings: normalizeImageGenerationToolSettings,
+    isEnabled(settings) {
+        return normalizeImageGenerationToolSettings(settings).enabled;
+    },
+};

package/dist/tools/image-generation/config.d.ts

@@ -0,0 +1,9 @@
+import type { ImageGenerationConfig, ImageGenerationRuntimeSettings } from "./shared";
+export type { ImageGenerationConfig } from "./shared";
+export declare function getImageGenerationToolDir(): string;
+export declare function getImageGenerationConfigPath(): string;
+export declare function loadImageGenerationConfig(options?: {
+    workspacePath?: string | null;
+    threadId?: string | null;
+    runtimeSettings?: ImageGenerationRuntimeSettings | null;
+}): ImageGenerationConfig;

package/dist/tools/image-generation/config.example.json

@@ -0,0 +1,14 @@
+{
+	"provider": "openai",
+	"baseUrl": "https://api.openai.com/v1",
+	"apiKey": "",
+	"model": "gpt-image-1",
+	"outputDir": ".axhub/sessions/image-generation",
+	"allowSavePath": true,
+	"savePathBaseDir": ".",
+	"preservePrompt": true,
+	"maxInputBytes": 10485760,
+	"maxOutputBytes": 52428800,
+	"downloadTimeoutMs": 30000,
+	"requestTimeoutMs": 180000
+}

package/dist/tools/image-generation/config.mjs

@@ -0,0 +1,11 @@
+import path from "node:path";
+import { getImageGenerationToolDir as getRuntimeImageGenerationToolDir, loadImageGenerationConfig as loadRuntimeImageGenerationConfig, } from "./service.mjs";
+export function getImageGenerationToolDir() {
+    return getRuntimeImageGenerationToolDir();
+}
+export function getImageGenerationConfigPath() {
+    return path.join(getImageGenerationToolDir(), "config.local.json");
+}
+export function loadImageGenerationConfig(options) {
+    return loadRuntimeImageGenerationConfig(options);
+}

package/dist/tools/image-generation/mcp-server.mjs

@@ -0,0 +1,87 @@
+#!/usr/bin/env node
+
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import {
+	generateImage,
+	IMAGE_GENERATION_MCP_NAME,
+	IMAGE_GENERATION_TOOL_NAME,
+} from "./service.mjs";
+
+const imageSourceSchema = z.object({
+	type: z.enum(["path", "url", "data_url", "base64"]),
+	value: z.string().min(1),
+	mimeType: z.string().optional(),
+	filename: z.string().optional(),
+});
+
+const inputSchema = {
+	prompt: z.string().min(1).describe("The image generation prompt."),
+	images: z
+		.array(imageSourceSchema)
+		.optional()
+		.describe(
+			"Optional reference images. Prefer local paths to keep ACP tool-call arguments small.",
+		),
+	model: z.string().optional(),
+	size: z.string().optional(),
+	quality: z.string().optional(),
+	outputFormat: z.enum(["png", "jpeg", "webp"]).optional(),
+	background: z.enum(["auto", "transparent", "opaque"]).optional(),
+	savePath: z
+		.string()
+		.optional()
+		.describe(
+			"Optional workspace-relative file path to also save the generated image, for example assets/generated/cover.png. Absolute paths and '..' segments are rejected.",
+		),
+};
+
+function readRuntimeSettings() {
+	const raw = process.env.ACP_UI_IMAGE_GENERATION_RUNTIME_SETTINGS;
+	if (!raw) return null;
+	try {
+		return JSON.parse(raw);
+	} catch {
+		return null;
+	}
+}
+
+const server = new McpServer({
+	name: IMAGE_GENERATION_MCP_NAME,
+	version: "0.1.0",
+});
+
+server.registerTool(
+	IMAGE_GENERATION_TOOL_NAME,
+	{
+		title: "Generate image",
+		description:
+			"Generate one image from a prompt, optionally using reference images by local path, URL, data URL, or base64. Prefer local paths. Optionally pass savePath to save a copy to a workspace-relative path. Mask editing is not supported.",
+		inputSchema,
+	},
+	async (input) => {
+		const output = await generateImage(input, {
+			source: "mcp",
+			workspacePath: process.env.ACP_UI_WORKSPACE_PATH || process.cwd(),
+			threadId: process.env.ACP_UI_THREAD_ID,
+			runtimeSettings: readRuntimeSettings(),
+		});
+		const failed = output.status === "failed";
+		return {
+			...(failed ? { isError: true } : {}),
+			content: [
+				{
+					type: "text",
+					text: failed
+						? (output.error ?? "Image generation failed.")
+						: "Generated 1 image.",
+				},
+			],
+			structuredContent: output,
+		};
+	},
+);
+
+const transport = new StdioServerTransport();
+await server.connect(transport);

package/dist/tools/image-generation/registry.d.ts

@@ -0,0 +1,13 @@
+import type { AcpMcpServer } from "../../lib/acp2aisdk/types";
+export declare function sanitizePersistedImageGenerationSettings(value: unknown): unknown;
+export declare const imageGenerationBuiltinTool: {
+    id: string;
+    getMcpServer(options: {
+        workspacePath?: string | null;
+        threadId?: string | null;
+        settings?: unknown;
+    }): AcpMcpServer | null;
+    getRuntimeKey(settings: unknown): unknown;
+    sanitizePersistedSettings(settings: unknown): unknown;
+    mergePersistedSettings(current: unknown, patch: unknown): unknown;
+};

package/dist/tools/image-generation/registry.mjs

@@ -0,0 +1,30 @@
+import { getImageGenerationMcpServer } from "./server.mjs";
+import { IMAGE_GENERATION_TOOL_ID, isRecord, mergeImageGenerationRuntimeSettings, normalizeImageGenerationRuntimeSettings, } from "./shared.mjs";
+export function sanitizePersistedImageGenerationSettings(value) {
+    if (!isRecord(value))
+        return null;
+    const savePathPattern = typeof value.savePathPattern === "string" ? value.savePathPattern : null;
+    const settings = Object.assign(Object.assign(Object.assign({}, (typeof value.enabled === "boolean" ? { enabled: value.enabled } : {})), (savePathPattern ? { savePathPattern } : {})), (typeof value.preservePrompt === "boolean"
+        ? { preservePrompt: value.preservePrompt }
+        : {}));
+    return Object.keys(settings).length > 0 ? settings : null;
+}
+export const imageGenerationBuiltinTool = {
+    id: IMAGE_GENERATION_TOOL_ID,
+    getMcpServer(options) {
+        return getImageGenerationMcpServer({
+            workspacePath: options.workspacePath,
+            threadId: options.threadId,
+            runtimeSettings: options.settings,
+        });
+    },
+    getRuntimeKey(settings) {
+        return normalizeImageGenerationRuntimeSettings(settings);
+    },
+    sanitizePersistedSettings(settings) {
+        return normalizeImageGenerationRuntimeSettings(sanitizePersistedImageGenerationSettings(settings));
+    },
+    mergePersistedSettings(current, patch) {
+        return mergeImageGenerationRuntimeSettings(current, sanitizePersistedImageGenerationSettings(patch));
+    },
+};

package/dist/tools/image-generation/server.d.ts

@@ -0,0 +1,6 @@
+import type { AcpMcpServer } from "../../lib/acp2aisdk/types";
+export declare function getImageGenerationMcpServer(options?: {
+    workspacePath?: string | null;
+    threadId?: string | null;
+    runtimeSettings?: unknown;
+}): AcpMcpServer | null;

package/dist/tools/image-generation/server.mjs

@@ -0,0 +1,58 @@
+import fs from "node:fs";
+import path from "node:path";
+import { getImageGenerationToolDir } from "./config.mjs";
+import { IMAGE_GENERATION_MCP_NAME, IMAGE_GENERATION_TOOL_ID, normalizeImageGenerationRuntimeSettings, } from "./shared.mjs";
+function mcpRuntimeSettings(settings) {
+    if (!settings)
+        return null;
+    const runtimeSettings = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, (settings.baseUrl ? { baseUrl: settings.baseUrl } : {})), (settings.apiKey ? { apiKey: settings.apiKey } : {})), (settings.model ? { model: settings.model } : {})), (settings.savePathPattern
+        ? { savePathPattern: settings.savePathPattern }
+        : {})), (typeof settings.preservePrompt === "boolean"
+        ? { preservePrompt: settings.preservePrompt }
+        : {}));
+    return Object.keys(runtimeSettings).length > 0 ? runtimeSettings : null;
+}
+export function getImageGenerationMcpServer(options = {}) {
+    const serverPath = path.join(getImageGenerationToolDir(), "mcp-server.mjs");
+    if (!fs.existsSync(serverPath))
+        return null;
+    const runtimeSettings = normalizeImageGenerationRuntimeSettings(options.runtimeSettings);
+    if ((runtimeSettings === null || runtimeSettings === void 0 ? void 0 : runtimeSettings.enabled) === false)
+        return null;
+    const serverRuntimeSettings = mcpRuntimeSettings(runtimeSettings);
+    return {
+        name: IMAGE_GENERATION_MCP_NAME,
+        command: process.execPath,
+        args: [serverPath],
+        env: [
+            {
+                name: "ACP_UI_TOOL_ID",
+                value: IMAGE_GENERATION_TOOL_ID,
+            },
+            ...(options.workspacePath
+                ? [
+                    {
+                        name: "ACP_UI_WORKSPACE_PATH",
+                        value: options.workspacePath,
+                    },
+                ]
+                : []),
+            ...(options.threadId
+                ? [
+                    {
+                        name: "ACP_UI_THREAD_ID",
+                        value: options.threadId,
+                    },
+                ]
+                : []),
+            ...(serverRuntimeSettings
+                ? [
+                    {
+                        name: "ACP_UI_IMAGE_GENERATION_RUNTIME_SETTINGS",
+                        value: JSON.stringify(serverRuntimeSettings),
+                    },
+                ]
+                : []),
+        ],
+    };
+}