@axhub/acp 0.1.0

package/dist/lib/api/client.d.ts

@@ -0,0 +1,93 @@
+import type { AcpCapabilitySnapshot, AcpChatRequest } from "../acp2aisdk";
+import type { AcpUiCommand } from "../acp2aisdk/commands";
+import type { AcpOutputArtifact } from "../../components/assistant-ui/addons/output-artifacts";
+import type { ConversationInitializeResponse, ConversationListResponse, ConversationMessagesResponse, ConversationMessageUpsertRequest, ConversationRecord, ConversationUpsertRequest } from "../conversations/types";
+import type { ImageGenerationRecord } from "../../tools/image-generation/shared";
+import type { UserChoicePendingRequest, UserChoiceToolResult } from "../../tools/user-choice/shared";
+export type AcpUiRuntimeConfig = {
+    apiBaseUrl?: string | null;
+    apiBasePath?: string | null;
+};
+type ConversationListOptions = {
+    limit?: number;
+    after?: string | null;
+    refreshProvider?: boolean;
+};
+type AcpQuery = {
+    provider: string;
+    threadId: string;
+    workspacePath?: string | null;
+};
+type CapabilityResponse = {
+    capabilitySnapshot: AcpCapabilitySnapshot | null;
+};
+type CommandsResponse = {
+    commands: AcpUiCommand[];
+};
+type WorkspaceOutputArtifactsResponse = {
+    artifacts: AcpOutputArtifact[];
+};
+declare global {
+    interface Window {
+        __ACP_UI_RUNTIME_CONFIG__?: AcpUiRuntimeConfig;
+    }
+}
+export declare function configureAcpUiRuntime(config: AcpUiRuntimeConfig): void;
+export declare function readAcpUiRuntimeConfig(): AcpUiRuntimeConfig;
+export declare const acpApiEndpoints: {
+    chat: () => string;
+    conversations: (workspacePath?: string | null, options?: ConversationListOptions) => string;
+    conversation: (threadId: string, workspacePath?: string | null) => string;
+    conversationMessages: (threadId: string, workspacePath?: string | null, format?: string | null) => string;
+    imageGenerationRecords: (workspacePath?: string | null, threadId?: string | null, limit?: number) => string;
+    userChoice: (query?: {
+        workspacePath?: string | null;
+        threadId?: string | null;
+        toolCallId?: string | null;
+        requestId?: string | null;
+    }) => string;
+    workspaceOutputArtifacts: (workspacePath?: string | null, threadId?: string | null, sinceMs?: number) => string;
+    capabilities: ({ provider, threadId, workspacePath }: AcpQuery) => string;
+    commands: ({ provider, threadId, workspacePath }: AcpQuery) => string;
+};
+export declare const acpApiClient: {
+    chatUrl(): string;
+    listConversations(workspacePath?: string | null, options?: ConversationListOptions): Promise<ConversationListResponse>;
+    upsertConversation(body: ConversationUpsertRequest, workspacePath?: string | null): Promise<ConversationInitializeResponse>;
+    getConversation(threadId: string, workspacePath?: string | null): Promise<{
+        thread: ConversationRecord;
+    }>;
+    renameConversation(threadId: string, title: string, workspacePath?: string | null): Promise<{
+        thread: ConversationRecord;
+    }>;
+    archiveConversation(threadId: string, archived: boolean, workspacePath?: string | null): Promise<{
+        thread: ConversationRecord;
+    }>;
+    deleteConversation(threadId: string, workspacePath?: string | null): Promise<void>;
+    loadConversationMessages<TContent extends Record<string, unknown>>(threadId: string, workspacePath: string | null | undefined, format: string): Promise<ConversationMessagesResponse<TContent>>;
+    saveConversationMessage<TContent extends Record<string, unknown>>(threadId: string, workspacePath: string | null | undefined, body: ConversationMessageUpsertRequest<TContent>): Promise<{
+        message: unknown;
+    }>;
+    listImageGenerationRecords(workspacePath: string | null | undefined, threadId: string | null | undefined, limit?: number): Promise<{
+        records: ImageGenerationRecord[];
+    }>;
+    getUserChoiceRequest(query: {
+        workspacePath?: string | null;
+        threadId?: string | null;
+        toolCallId?: string | null;
+        requestId?: string | null;
+    }): Promise<{
+        request: UserChoicePendingRequest | null;
+    }>;
+    answerUserChoiceRequest(body: {
+        workspacePath?: string | null;
+        requestId: string;
+        answer: UserChoiceToolResult;
+    }): Promise<{
+        request: UserChoicePendingRequest;
+    }>;
+    listWorkspaceOutputArtifacts(workspacePath: string | null | undefined, threadId: string | null | undefined, sinceMs: number): Promise<WorkspaceOutputArtifactsResponse>;
+    getCapabilities(query: AcpQuery): Promise<CapabilityResponse>;
+    listCommands(query: AcpQuery): Promise<CommandsResponse>;
+};
+export type { AcpChatRequest };

package/dist/lib/api/client.mjs

@@ -0,0 +1,199 @@
+"use client";
+const DEFAULT_API_BASE_URL = "/api";
+const RUNTIME_CONFIG_SEARCH_PARAMS = {
+    apiBasePath: "acpApiBasePath",
+    apiBaseUrl: "acpApiBaseUrl",
+};
+let configuredRuntimeConfig = {};
+function normalizeBaseUrl(value) {
+    const normalized = String(value !== null && value !== void 0 ? value : "").trim();
+    if (!normalized)
+        return DEFAULT_API_BASE_URL;
+    return normalized.replace(/\/+$/, "");
+}
+function normalizeRuntimeConfig(config) {
+    return {
+        apiBasePath: normalizeOptionalConfigValue(config === null || config === void 0 ? void 0 : config.apiBasePath),
+        apiBaseUrl: normalizeOptionalConfigValue(config === null || config === void 0 ? void 0 : config.apiBaseUrl),
+    };
+}
+function normalizeOptionalConfigValue(value) {
+    const normalized = String(value !== null && value !== void 0 ? value : "").trim();
+    return normalized ? normalized : null;
+}
+function readWindowRuntimeConfig() {
+    return typeof window === "undefined"
+        ? {}
+        : normalizeRuntimeConfig(window.__ACP_UI_RUNTIME_CONFIG__);
+}
+function readSearchParamRuntimeConfig() {
+    if (typeof window === "undefined")
+        return {};
+    const searchParams = new URLSearchParams(window.location.search);
+    return normalizeRuntimeConfig({
+        apiBasePath: searchParams.get(RUNTIME_CONFIG_SEARCH_PARAMS.apiBasePath),
+        apiBaseUrl: searchParams.get(RUNTIME_CONFIG_SEARCH_PARAMS.apiBaseUrl),
+    });
+}
+export function configureAcpUiRuntime(config) {
+    configuredRuntimeConfig = normalizeRuntimeConfig(Object.assign(Object.assign({}, configuredRuntimeConfig), config));
+    if (typeof window !== "undefined") {
+        window.__ACP_UI_RUNTIME_CONFIG__ = Object.assign(Object.assign({}, window.__ACP_UI_RUNTIME_CONFIG__), configuredRuntimeConfig);
+    }
+}
+export function readAcpUiRuntimeConfig() {
+    return normalizeRuntimeConfig(Object.assign(Object.assign({}, configuredRuntimeConfig), readWindowRuntimeConfig()));
+}
+function runtimeApiBaseUrl() {
+    var _a, _b;
+    const runtimeConfig = readAcpUiRuntimeConfig();
+    return (_b = (_a = runtimeConfig.apiBaseUrl) !== null && _a !== void 0 ? _a : runtimeConfig.apiBasePath) !== null && _b !== void 0 ? _b : null;
+}
+function searchParamApiBaseUrl() {
+    var _a, _b;
+    const searchParamConfig = readSearchParamRuntimeConfig();
+    return (_b = (_a = searchParamConfig.apiBaseUrl) !== null && _a !== void 0 ? _a : searchParamConfig.apiBasePath) !== null && _b !== void 0 ? _b : null;
+}
+function envApiBaseUrl() {
+    var _a;
+    return ((_a = normalizeOptionalConfigValue(process.env.NEXT_PUBLIC_ACP_UI_API_BASE_URL)) !== null && _a !== void 0 ? _a : normalizeOptionalConfigValue(process.env.NEXT_PUBLIC_ACP_UI_API_BASE_PATH));
+}
+function apiBaseUrl() {
+    var _a, _b;
+    return normalizeBaseUrl((_b = (_a = runtimeApiBaseUrl()) !== null && _a !== void 0 ? _a : searchParamApiBaseUrl()) !== null && _b !== void 0 ? _b : envApiBaseUrl());
+}
+function currentOrigin() {
+    return typeof window === "undefined"
+        ? "http://localhost"
+        : window.location.origin;
+}
+function buildApiUrl(path, query) {
+    const normalizedPath = path.startsWith("/") ? path : `/${path}`;
+    const baseUrl = apiBaseUrl();
+    const origin = currentOrigin();
+    const url = new URL(`${baseUrl}${normalizedPath}`, origin);
+    for (const [key, value] of Object.entries(query !== null && query !== void 0 ? query : {})) {
+        if (value === null || value === undefined || value === "")
+            continue;
+        url.searchParams.set(key, String(value));
+    }
+    if (url.origin === origin) {
+        return `${url.pathname}${url.search}`;
+    }
+    return url.toString();
+}
+async function requestJson(input, init) {
+    var _a;
+    const response = await fetch(input, Object.assign(Object.assign({}, init), { headers: Object.assign({ "content-type": "application/json" }, init === null || init === void 0 ? void 0 : init.headers) }));
+    if (!response.ok) {
+        const fallback = `${response.status} ${response.statusText}`;
+        const body = (await response.json().catch(() => null));
+        throw new Error((_a = body === null || body === void 0 ? void 0 : body.error) !== null && _a !== void 0 ? _a : fallback);
+    }
+    return response.json();
+}
+function conversationQuery(workspacePath, options) {
+    return {
+        workspacePath,
+        limit: options === null || options === void 0 ? void 0 : options.limit,
+        after: options === null || options === void 0 ? void 0 : options.after,
+        refreshProvider: options === null || options === void 0 ? void 0 : options.refreshProvider,
+    };
+}
+function conversationPath(threadId) {
+    return `/conversations/${encodeURIComponent(threadId)}`;
+}
+function conversationMessagesPath(threadId) {
+    return `${conversationPath(threadId)}/messages`;
+}
+function imageGenerationRecordsPath() {
+    return "/tools/image-generation/records";
+}
+function userChoicePath() {
+    return "/tools/user-choice";
+}
+export const acpApiEndpoints = {
+    chat: () => buildApiUrl("/chat"),
+    conversations: (workspacePath, options) => buildApiUrl("/conversations", conversationQuery(workspacePath, options)),
+    conversation: (threadId, workspacePath) => buildApiUrl(conversationPath(threadId), { workspacePath }),
+    conversationMessages: (threadId, workspacePath, format) => buildApiUrl(conversationMessagesPath(threadId), {
+        workspacePath,
+        format,
+    }),
+    imageGenerationRecords: (workspacePath, threadId, limit) => buildApiUrl(imageGenerationRecordsPath(), {
+        workspacePath,
+        threadId,
+        limit,
+    }),
+    userChoice: (query) => buildApiUrl(userChoicePath(), query),
+    workspaceOutputArtifacts: (workspacePath, threadId, sinceMs) => buildApiUrl("/output-artifacts/workspace", { workspacePath, threadId, sinceMs }),
+    capabilities: ({ provider, threadId, workspacePath }) => buildApiUrl("/acp/capabilities", { provider, threadId, workspacePath }),
+    commands: ({ provider, threadId, workspacePath }) => buildApiUrl("/acp/commands", { provider, threadId, workspacePath }),
+};
+export const acpApiClient = {
+    chatUrl() {
+        return acpApiEndpoints.chat();
+    },
+    async listConversations(workspacePath, options) {
+        return requestJson(acpApiEndpoints.conversations(workspacePath, options));
+    },
+    async upsertConversation(body, workspacePath) {
+        return requestJson(acpApiEndpoints.conversations(workspacePath), {
+            method: "POST",
+            body: JSON.stringify(body),
+        });
+    },
+    async getConversation(threadId, workspacePath) {
+        return requestJson(acpApiEndpoints.conversation(threadId, workspacePath));
+    },
+    async renameConversation(threadId, title, workspacePath) {
+        return requestJson(acpApiEndpoints.conversation(threadId, workspacePath), {
+            method: "PATCH",
+            body: JSON.stringify({ title }),
+        });
+    },
+    async archiveConversation(threadId, archived, workspacePath) {
+        return requestJson(acpApiEndpoints.conversation(threadId, workspacePath), {
+            method: "PATCH",
+            body: JSON.stringify({ archived }),
+        });
+    },
+    async deleteConversation(threadId, workspacePath) {
+        const response = await fetch(acpApiEndpoints.conversation(threadId, workspacePath), {
+            method: "DELETE",
+        });
+        if (!response.ok) {
+            throw new Error(`${response.status} ${response.statusText}`);
+        }
+    },
+    async loadConversationMessages(threadId, workspacePath, format) {
+        return requestJson(acpApiEndpoints.conversationMessages(threadId, workspacePath, format));
+    },
+    async saveConversationMessage(threadId, workspacePath, body) {
+        return requestJson(acpApiEndpoints.conversationMessages(threadId, workspacePath, body.format), {
+            method: "POST",
+            body: JSON.stringify(body),
+        });
+    },
+    async listImageGenerationRecords(workspacePath, threadId, limit) {
+        return requestJson(acpApiEndpoints.imageGenerationRecords(workspacePath, threadId, limit));
+    },
+    async getUserChoiceRequest(query) {
+        return requestJson(acpApiEndpoints.userChoice(query));
+    },
+    async answerUserChoiceRequest(body) {
+        return requestJson(acpApiEndpoints.userChoice(), {
+            method: "POST",
+            body: JSON.stringify(body),
+        });
+    },
+    async listWorkspaceOutputArtifacts(workspacePath, threadId, sinceMs) {
+        return requestJson(acpApiEndpoints.workspaceOutputArtifacts(workspacePath, threadId, sinceMs));
+    },
+    async getCapabilities(query) {
+        return requestJson(acpApiEndpoints.capabilities(query));
+    },
+    async listCommands(query) {
+        return requestJson(acpApiEndpoints.commands(query));
+    },
+};

package/dist/lib/api/cors.d.ts

@@ -0,0 +1,2 @@
+export declare function withCors(request: Request, response: Response): Response;
+export declare function corsPreflightResponse(request: Request): Response;

package/dist/lib/api/cors.mjs

@@ -0,0 +1,47 @@
+const ALLOWED_METHODS = "GET,POST,PATCH,DELETE,OPTIONS";
+const DEFAULT_ALLOWED_HEADERS = "Content-Type, Authorization, X-Requested-With, Accept";
+function configuredOrigins() {
+    var _a;
+    return ((_a = process.env.ACP_UI_CORS_ORIGINS) !== null && _a !== void 0 ? _a : "")
+        .split(",")
+        .map((origin) => origin.trim())
+        .filter(Boolean);
+}
+function allowedOrigin(requestOrigin) {
+    if (!requestOrigin)
+        return null;
+    const origins = configuredOrigins();
+    if (origins.includes("*"))
+        return "*";
+    return origins.includes(requestOrigin) ? requestOrigin : null;
+}
+function appendVaryOrigin(headers) {
+    const vary = headers.get("Vary");
+    if (!vary) {
+        headers.set("Vary", "Origin");
+        return;
+    }
+    const values = vary.split(",").map((value) => value.trim().toLowerCase());
+    if (!values.includes("origin"))
+        headers.set("Vary", `${vary}, Origin`);
+}
+export function withCors(request, response) {
+    var _a;
+    const origin = allowedOrigin(request.headers.get("origin"));
+    if (!origin)
+        return response;
+    const headers = new Headers(response.headers);
+    headers.set("Access-Control-Allow-Origin", origin);
+    headers.set("Access-Control-Allow-Methods", ALLOWED_METHODS);
+    headers.set("Access-Control-Allow-Headers", (_a = request.headers.get("access-control-request-headers")) !== null && _a !== void 0 ? _a : DEFAULT_ALLOWED_HEADERS);
+    headers.set("Access-Control-Max-Age", "86400");
+    appendVaryOrigin(headers);
+    return new Response(response.body, {
+        headers,
+        status: response.status,
+        statusText: response.statusText,
+    });
+}
+export function corsPreflightResponse(request) {
+    return withCors(request, new Response(null, { status: 204 }));
+}

package/dist/lib/conversations/client-adapter.d.ts

@@ -0,0 +1,21 @@
+import type { AcpBuiltinToolSettings, AcpProviderKey } from "../acp2aisdk";
+import type { ContextBundleV2 } from "../acp2aisdk/context";
+type AcpThreadContext = {
+    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;
+    consumeContextBundle?: () => ContextBundleV2 | null;
+};
+type ConversationRuntimeOptions = {
+    context?: AcpThreadContext;
+    threadId?: string;
+};
+export declare function useConversationChatRuntime({ context, threadId, }?: ConversationRuntimeOptions): import("@assistant-ui/core").AssistantRuntime;
+export {};