@xpert-ai/xpert-sdk 0.0.17 → 0.1.0

package/dist/schema.d.ts

@@ -463,6 +463,234 @@ export type RuntimeI18nObject = {
     [locale: string]: string | undefined;
 };
 export type RuntimeI18nText = string | RuntimeI18nObject;
+export type XpertProjectStatus = "active" | "deprecated" | "archived";
+export type XpertProjectAvailabilityStatus = "active" | "archived" | "all";
+export type XpertProject = {
+    id: string;
+    name: string;
+    description?: string;
+    status: XpertProjectStatus;
+    /** @deprecated Projects no longer use a workspace as their collaboration boundary. */
+    workspaceId?: string;
+    avatar?: Record<string, unknown> | string | null;
+    createdAt?: string;
+    updatedAt?: string;
+};
+export type XpertProjectListOptions = {
+    /** Only projects containing this Xpert are returned. */
+    xpertId: string;
+    status?: XpertProjectAvailabilityStatus;
+    skip?: number;
+    take?: number;
+    signal?: AbortSignal;
+};
+/**
+ * File or directory returned by an Xpert workspace volume listing.
+ * `filePath` is the entry name while `fullPath` is relative to the workspace root.
+ */
+export type XpertWorkspaceFile = {
+    filePath: string;
+    fullPath?: string;
+    directory?: string;
+    fileType?: string;
+    fileUrl?: string;
+    url?: string;
+    mimeType?: string;
+    size?: number;
+    createdAt?: string;
+    updatedAt?: string;
+    hasChildren?: boolean;
+    children?: XpertWorkspaceFile[] | null;
+};
+export type XpertWorkspaceFileListOptions = {
+    path?: string;
+    depth?: number;
+    signal?: AbortSignal;
+};
+export type XpertWorkspaceStatus = "active" | "deprecated" | "archived";
+export type XpertWorkspaceAccessPurpose = "runtime" | "authoring";
+export type XpertWorkspace = {
+    id: string;
+    name: string;
+    description?: string;
+    status: XpertWorkspaceStatus;
+    ownerId: string;
+    capabilities?: {
+        canRead: boolean;
+        canRun: boolean;
+        canWrite: boolean;
+        canManage: boolean;
+    };
+    isTenantShared?: boolean;
+    createdAt?: string;
+    updatedAt?: string;
+};
+export type XpertWorkspaceDefaultOptions = {
+    purpose?: XpertWorkspaceAccessPurpose;
+    signal?: AbortSignal;
+};
+export type ConnectorStatus = "pending" | "active" | "expired" | "error" | "disconnected";
+export type ConnectorAuthorizationMode = "personal" | "shared";
+export type ConnectorScope = {
+    type: "workspace";
+    workspaceId: string;
+} | {
+    type: "project";
+    projectId: string;
+};
+export type ConnectorAppCredentialField = {
+    name: string;
+    label: RuntimeI18nText;
+    type?: "text" | "password";
+    required?: boolean;
+    placeholder?: RuntimeI18nText;
+    description?: RuntimeI18nText;
+    secret?: boolean;
+};
+export type ConnectorCredentialFormDefinition = {
+    fields?: ConnectorAppCredentialField[];
+    help?: {
+        label: RuntimeI18nText;
+        url: string;
+    };
+    defaultValues?: Record<string, string | number | boolean | null>;
+};
+export type ConnectorAuthMethodDefinition = {
+    id: string;
+    type: "oauth2";
+    label: RuntimeI18nText;
+    appCredentials?: ConnectorCredentialFormDefinition;
+} | {
+    id: string;
+    type: "api_key";
+    label: RuntimeI18nText;
+    credentials: ConnectorCredentialFormDefinition;
+};
+export type ConnectorDefinitionBase = {
+    provider: string;
+    label: RuntimeI18nText;
+    description?: RuntimeI18nText;
+    icon?: IconDefinition;
+    legacyAuthMethodId?: string;
+    /** Missing values are treated as shared-only for legacy providers. */
+    authorizationModes?: ConnectorAuthorizationMode[];
+};
+export type ConnectorStrategyDefinition = ConnectorDefinitionBase & ({
+    auth: {
+        type: "oauth2";
+        authorizationUrl?: string;
+        tokenUrl?: string;
+        userInfoUrl?: string;
+        scopes?: string[];
+        redirectPath?: string;
+    };
+    appCredentials?: ConnectorCredentialFormDefinition;
+} | {
+    authMethods: ConnectorAuthMethodDefinition[];
+    auth?: {
+        type: "oauth2";
+        authorizationUrl?: string;
+        tokenUrl?: string;
+        userInfoUrl?: string;
+        scopes?: string[];
+        redirectPath?: string;
+    };
+    appCredentials?: ConnectorCredentialFormDefinition;
+});
+export type ConnectorProfile = {
+    openId?: string;
+    unionId?: string;
+    userId?: string;
+    name?: string;
+    avatarUrl?: string;
+    email?: string;
+    [key: string]: unknown;
+};
+export type ConnectorInstance = {
+    id: string;
+    bindingId?: string;
+    accountId?: string;
+    workspaceId?: string | null;
+    projectId?: string | null;
+    provider: string;
+    authMethodId?: string | null;
+    status: ConnectorStatus;
+    profile?: ConnectorProfile | null;
+    scopes?: string[];
+    expiresAt?: string | null;
+    refreshExpiresAt?: string | null;
+    connectedAt?: string | null;
+    disconnectedAt?: string | null;
+    lastError?: string | null;
+    createdAt?: string;
+    updatedAt?: string;
+};
+export type ConnectorBinding = ConnectorInstance & {
+    scopeType: ConnectorScope["type"];
+    scope: ConnectorScope;
+    authorizationMode: ConnectorAuthorizationMode;
+};
+export type ConnectorRuntimeOption = {
+    bindingId: string;
+    provider: string;
+    authorizationMode: ConnectorAuthorizationMode;
+    status: ConnectorStatus;
+    granted: boolean;
+    profile?: ConnectorProfile | null;
+    label: RuntimeI18nText;
+    description?: RuntimeI18nText;
+    icon?: IconDefinition;
+    authMethods?: ConnectorAuthMethodDefinition[];
+};
+export type ConnectorRuntimeOptions = {
+    scope: ConnectorScope;
+    items: ConnectorRuntimeOption[];
+};
+export type ConnectorRuntimeOptionsResponse = ConnectorRuntimeOptions;
+export type ConnectorBindingCreateRequest = {
+    scope: ConnectorScope;
+    provider: string;
+    authorizationMode: ConnectorAuthorizationMode;
+};
+export type ConnectorPersonalAccountInstance = {
+    id: string;
+    provider: string;
+    status: ConnectorStatus;
+    authMethodId?: string | null;
+    profile?: ConnectorProfile | null;
+    scopes?: string[];
+    expiresAt?: string | null;
+    connectedAt?: string | null;
+    disconnectedAt?: string | null;
+    lastError?: string | null;
+};
+/** @deprecated Use ConnectorPersonalAccountInstance. */
+export type PersonalConnectorAccount = ConnectorPersonalAccountInstance;
+export type ConnectorConnectRequest = {
+    authMethodId?: string;
+    values?: Record<string, unknown>;
+    xpertId?: string;
+    /** @deprecated Use values instead. */
+    app?: Record<string, unknown>;
+};
+export type ConnectorConsentRequest = {
+    xpertId?: string;
+};
+export type ConnectorConnectResponse = {
+    status: "active" | "pending";
+    connector: ConnectorInstance;
+    authorizationUrl?: string | null;
+    stateExpiresAt?: string | null;
+    pollIntervalSeconds?: number | null;
+};
+export type ConnectorOAuthStatusResponse = {
+    connector: ConnectorInstance;
+    granted?: boolean;
+    authorizationUrl?: string | null;
+    stateExpiresAt?: string | null;
+    pollIntervalSeconds?: number | null;
+    message?: string | null;
+};
 export type RuntimePromptWorkflow = {
     type: "prompt_workflow";
     name?: string;
@@ -502,6 +730,9 @@ export type RuntimeCapabilitiesSelectionSet = {
     subAgents?: {
         nodeKeys: string[];
     };
+    connectors?: {
+        bindingIds: string[];
+    };
 };
 export type RuntimeCapabilitiesSelection = RuntimeCapabilitiesSelectionSet & {
     mode: "allowlist";
@@ -700,6 +931,9 @@ export type ChatConversationStatus = "idle" | "busy" | "interrupted" | "error";
 export type ThreadGoalStatus = "active" | "paused" | "blocked" | "usage_limited" | "budget_limited" | "complete";
 export type ThreadGoalUserStatus = Extract<ThreadGoalStatus, "active" | "paused">;
 export type ChatConversationFrom = "platform" | "webapp" | "debugger" | "knowledge" | "job" | "api" | "feishu" | "lark" | "dingtalk" | "wecom";
+export type ChatConversationOptions = Record<string, unknown> & {
+    runtimeCapabilities?: RuntimeCapabilitiesSelection | null;
+};
 export interface ChatConversation {
     id: string;
     threadId: string;
@@ -707,7 +941,7 @@ export interface ChatConversation {
     status?: ChatConversationStatus;
     from?: ChatConversationFrom;
     fromEndUserId?: string;
-    options?: Record<string, unknown>;
+    options?: ChatConversationOptions;
     error?: string;
     operation?: Record<string, unknown>;
     xpertId?: string;
@@ -716,6 +950,35 @@ export interface ChatConversation {
     createdAt?: string;
     updatedAt?: string;
 }
+export type ChatConversationFileStatus = "uploaded" | "scanning" | "parsing" | "ready" | "partial" | "failed";
+export type ChatConversationFilePurpose = "chat_attachment" | "workspace" | "knowledge";
+export type ChatConversationFileParseMode = "auto" | "fast" | "deep" | "none";
+/**
+ * Agent-readable file attached to a conversation.
+ */
+export interface ChatConversationFile {
+    id: string;
+    storageFileId?: string;
+    conversationId?: string;
+    threadId?: string;
+    projectId?: string;
+    xpertId?: string;
+    originalName?: string;
+    fileName?: string;
+    mimeType?: string;
+    size?: number;
+    purpose: ChatConversationFilePurpose;
+    parseMode: ChatConversationFileParseMode;
+    status: ChatConversationFileStatus;
+    capabilities?: string[];
+    workspacePath?: string;
+    summary?: string;
+    error?: string;
+    parsedAt?: string;
+    failedAt?: string;
+    createdAt?: string;
+    updatedAt?: string;
+}
 export interface ThreadGoal {
     id: string;
     conversationId: string;

package/dist/tests/projects-connectors.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/projects-connectors.test.js

@@ -0,0 +1,372 @@
+import { describe, expect, it, vi } from "vitest";
+import { Client } from "../index.js";
+function jsonResponse(value, status = 200) {
+    return new Response(JSON.stringify(value), {
+        status,
+        headers: { "content-type": "application/json" },
+    });
+}
+describe("ProjectsClient", () => {
+    it("lists only projects available to an Xpert and preserves request hooks", async () => {
+        const projects = [
+            {
+                id: "project-1",
+                name: "Launch plan",
+                status: "active",
+            },
+        ];
+        const fetchMock = vi
+            .fn()
+            .mockResolvedValue(jsonResponse({ items: projects, total: 1 }));
+        const onRequest = vi.fn((_url, init) => ({
+            ...init,
+            headers: { ...init.headers, "organization-id": "org-1" },
+        }));
+        const client = new Client({
+            apiUrl: "https://xpert.example/api/ai/",
+            apiKey: "secret",
+            callerOptions: { fetch: fetchMock },
+            onRequest,
+        });
+        await expect(client.projects.list({ xpertId: "xpert/1" })).resolves.toEqual({
+            items: projects,
+            total: 1,
+        });
+        const [url, init] = fetchMock.mock.calls[0] ?? [];
+        expect(url.pathname).toBe("/api/xpert-project/available");
+        expect(url.searchParams.get("xpertId")).toBe("xpert/1");
+        expect(url.searchParams.get("status")).toBe("active");
+        expect(url.searchParams.get("skip")).toBe("0");
+        expect(url.searchParams.get("take")).toBe("100");
+        expect(init?.headers).toMatchObject({
+            "organization-id": "org-1",
+            "x-api-key": "secret",
+        });
+        expect(onRequest).toHaveBeenCalledOnce();
+    });
+    it("gets a project by encoded id", async () => {
+        const project = {
+            id: "project/1",
+            name: "Launch plan",
+            status: "active",
+        };
+        const fetchMock = vi
+            .fn()
+            .mockResolvedValue(jsonResponse(project));
+        const client = new Client({
+            apiUrl: "https://xpert.example/api/ai",
+            callerOptions: { fetch: fetchMock },
+        });
+        await expect(client.projects.get("project/1")).resolves.toEqual(project);
+        expect((fetchMock.mock.calls[0]?.[0]).pathname).toBe("/api/xpert-project/project%2F1");
+    });
+    it("requests all project statuses explicitly", async () => {
+        const fetchMock = vi
+            .fn()
+            .mockResolvedValue(jsonResponse({ items: [], total: 0 }));
+        const client = new Client({
+            apiUrl: "https://xpert.example/api/ai",
+            callerOptions: { fetch: fetchMock },
+        });
+        await client.projects.list({
+            xpertId: "xpert-1",
+            status: "all",
+            skip: 10,
+            take: 20,
+        });
+        const url = fetchMock.mock.calls[0]?.[0];
+        expect(url.searchParams.get("xpertId")).toBe("xpert-1");
+        expect(url.searchParams.get("status")).toBe("all");
+        expect(url.searchParams.get("skip")).toBe("10");
+        expect(url.searchParams.get("take")).toBe("20");
+    });
+    it("lists project workspace files with the requested depth", async () => {
+        const files = [
+            {
+                filePath: "briefs",
+                hasChildren: true,
+                children: [
+                    { filePath: "briefs/product.pdf", mimeType: "application/pdf" },
+                ],
+            },
+        ];
+        const fetchMock = vi
+            .fn()
+            .mockResolvedValue(jsonResponse(files));
+        const client = new Client({
+            apiUrl: "https://xpert.example/api/ai",
+            apiKey: "secret",
+            callerOptions: { fetch: fetchMock },
+        });
+        await expect(client.projects.listFiles("project/1", {
+            path: "briefs",
+            depth: 8,
+        })).resolves.toEqual(files);
+        const [url, init] = fetchMock.mock.calls[0] ?? [];
+        expect(url.pathname).toBe("/api/xpert-project/project%2F1/files");
+        expect(url.searchParams.get("path")).toBe("briefs");
+        expect(url.searchParams.get("deepth")).toBe("8");
+        expect(init?.headers).toMatchObject({ "x-api-key": "secret" });
+    });
+});
+describe("AssistantsClient runtime capabilities", () => {
+    it("scopes runtime capabilities to the selected project", async () => {
+        const fetchMock = vi
+            .fn()
+            .mockResolvedValue(jsonResponse({ skills: [], plugins: [] }));
+        const controller = new AbortController();
+        const client = new Client({
+            apiUrl: "https://xpert.example/api/ai",
+            callerOptions: { fetch: fetchMock },
+        });
+        await client.assistants.getRuntimeCapabilities("xpert/1", {
+            projectId: "project/1",
+            signal: controller.signal,
+        });
+        const [url, init] = fetchMock.mock.calls[0] ?? [];
+        expect(url.pathname).toBe("/api/ai/assistants/xpert/1/runtime-capabilities");
+        expect(url.searchParams.get("projectId")).toBe("project/1");
+        expect(init?.signal).toBe(controller.signal);
+    });
+});
+describe("XpertsClient", () => {
+    it("lists an assistants workspace files without a conversation", async () => {
+        const files = [
+            { filePath: "project.md", mimeType: "text/markdown", size: 42 },
+        ];
+        const fetchMock = vi
+            .fn()
+            .mockResolvedValue(jsonResponse(files));
+        const controller = new AbortController();
+        const client = new Client({
+            apiUrl: "https://xpert.example/api/ai",
+            callerOptions: { fetch: fetchMock },
+        });
+        await expect(client.xperts.listWorkspaceFiles("assistant/1", {
+            depth: 12,
+            signal: controller.signal,
+        })).resolves.toEqual(files);
+        const [url, init] = fetchMock.mock.calls[0] ?? [];
+        expect(url.pathname).toBe("/api/xpert/assistant%2F1/workspace/files");
+        expect(url.searchParams.get("deepth")).toBe("12");
+        expect(init?.signal).toBe(controller.signal);
+    });
+});
+describe("WorkspacesClient", () => {
+    it("gets the current users default authoring workspace", async () => {
+        const workspace = {
+            id: "workspace-1",
+            name: "Personal workspace",
+            status: "active",
+            ownerId: "user-1",
+        };
+        const fetchMock = vi
+            .fn()
+            .mockResolvedValue(jsonResponse(workspace));
+        const client = new Client({
+            apiUrl: "https://xpert.example/api/ai",
+            apiKey: "secret",
+            callerOptions: { fetch: fetchMock },
+        });
+        await expect(client.workspaces.getDefault({ purpose: "authoring" })).resolves.toEqual(workspace);
+        const [url, init] = fetchMock.mock.calls[0] ?? [];
+        expect(url.pathname).toBe("/api/xpert-workspace/my/default");
+        expect(url.searchParams.get("purpose")).toBe("authoring");
+        expect(init?.headers).toMatchObject({ "x-api-key": "secret" });
+    });
+});
+describe("ConnectorsClient", () => {
+    it("loads runtime options for the Xpert and selected project", async () => {
+        const response = {
+            scope: { type: "project", projectId: "project-1" },
+            items: [
+                {
+                    bindingId: "binding-1",
+                    provider: "google-drive",
+                    authorizationMode: "personal",
+                    status: "active",
+                    granted: true,
+                    label: "Google Drive",
+                    authMethods: [
+                        { id: "oauth2", type: "oauth2", label: "OAuth" },
+                    ],
+                },
+            ],
+        };
+        const fetchMock = vi
+            .fn()
+            .mockResolvedValue(jsonResponse(response));
+        const client = new Client({
+            apiUrl: "https://xpert.example/api/ai",
+            callerOptions: { fetch: fetchMock },
+        });
+        await expect(client.connectors.runtimeOptions("xpert/1", {
+            projectId: "project/1",
+        })).resolves.toEqual(response);
+        const url = fetchMock.mock.calls[0]?.[0];
+        expect(url.pathname).toBe("/api/connector/runtime-options");
+        expect(url.searchParams.get("xpertId")).toBe("xpert/1");
+        expect(url.searchParams.get("projectId")).toBe("project/1");
+    });
+    it("lists definitions and bindings for a typed scope", async () => {
+        const definitions = [
+            {
+                provider: "google-drive",
+                label: { en_US: "Google Drive", zh_Hans: "Google Drive" },
+                auth: { type: "oauth2" },
+            },
+        ];
+        const bindings = [
+            {
+                id: "binding-1",
+                scopeType: "project",
+                scope: { type: "project", projectId: "project-1" },
+                projectId: "project-1",
+                provider: "google-drive",
+                authorizationMode: "shared",
+                status: "active",
+            },
+        ];
+        const fetchMock = vi
+            .fn()
+            .mockResolvedValueOnce(jsonResponse(definitions))
+            .mockResolvedValueOnce(jsonResponse(bindings));
+        const client = new Client({
+            apiUrl: "https://xpert.example/api/ai",
+            callerOptions: { fetch: fetchMock },
+        });
+        const scope = { type: "project", projectId: "project/1" };
+        await expect(client.connectors.definitions(scope)).resolves.toEqual(definitions);
+        await expect(client.connectors.listBindings(scope)).resolves.toEqual(bindings);
+        expect((fetchMock.mock.calls[0]?.[0]).pathname).toBe("/api/connector/definitions");
+        expect((fetchMock.mock.calls[0]?.[0]).searchParams.get("scopeType")).toBe("project");
+        expect((fetchMock.mock.calls[0]?.[0]).searchParams.get("scopeId")).toBe("project/1");
+        expect((fetchMock.mock.calls[1]?.[0]).pathname).toBe("/api/connector/bindings");
+    });
+    it("starts and polls connector authorization with typed payloads", async () => {
+        const connectInput = {
+            authMethodId: "oauth2",
+            xpertId: "xpert-1",
+        };
+        const pending = {
+            status: "pending",
+            connector: {
+                id: "connector-1",
+                workspaceId: "workspace-1",
+                provider: "google-drive",
+                authMethodId: "oauth2",
+                status: "pending",
+            },
+            authorizationUrl: "https://accounts.example/authorize",
+            pollIntervalSeconds: 5,
+        };
+        const active = {
+            connector: { ...pending.connector, status: "active" },
+            granted: true,
+        };
+        const fetchMock = vi
+            .fn()
+            .mockResolvedValueOnce(jsonResponse(pending))
+            .mockResolvedValueOnce(jsonResponse(active));
+        const client = new Client({
+            apiUrl: "https://xpert.example/api/ai",
+            callerOptions: { fetch: fetchMock },
+        });
+        await expect(client.connectors.connect("binding/1", connectInput)).resolves.toEqual(pending);
+        await expect(client.connectors.authorizationStatus("binding/1", {
+            xpertId: "xpert-1",
+        })).resolves.toEqual(active);
+        const [connectUrl, connectInit] = fetchMock.mock.calls[0] ?? [];
+        expect(connectUrl.pathname).toBe("/api/connector/bindings/binding%2F1/connect");
+        expect(connectInit?.method).toBe("POST");
+        expect(connectInit?.body).toBe(JSON.stringify(connectInput));
+        expect((fetchMock.mock.calls[1]?.[0]).pathname).toBe("/api/connector/bindings/binding%2F1/authorization-status");
+        expect((fetchMock.mock.calls[1]?.[0]).searchParams.get("xpertId")).toBe("xpert-1");
+    });
+    it("records personal Connector consent in the current Xpert context", async () => {
+        const granted = {
+            id: "binding-1",
+            provider: "google-drive",
+            scopeType: "project",
+            scope: { type: "project", projectId: "project-1" },
+            projectId: "project-1",
+            authorizationMode: "personal",
+            status: "active",
+            profile: { name: "Alice" },
+        };
+        const fetchMock = vi
+            .fn()
+            .mockResolvedValue(jsonResponse(granted));
+        const client = new Client({
+            apiUrl: "https://xpert.example/api/ai",
+            callerOptions: { fetch: fetchMock },
+        });
+        await expect(client.connectors.consent("binding/1", { xpertId: "xpert-1" })).resolves.toEqual(granted);
+        const [url, init] = fetchMock.mock.calls[0] ?? [];
+        expect(url.pathname).toBe("/api/connector/bindings/binding%2F1/consent");
+        expect(init?.method).toBe("POST");
+        expect(init?.body).toBe(JSON.stringify({ xpertId: "xpert-1" }));
+    });
+    it("lists the current users personal Connector accounts", async () => {
+        const accounts = [
+            {
+                id: "account-1",
+                provider: "google-drive",
+                status: "active",
+                profile: { name: "Alice" },
+            },
+        ];
+        const fetchMock = vi
+            .fn()
+            .mockResolvedValue(jsonResponse(accounts));
+        const controller = new AbortController();
+        const client = new Client({
+            apiUrl: "https://xpert.example/api/ai",
+            callerOptions: { fetch: fetchMock },
+        });
+        await expect(client.connectors.listPersonalAccounts({ signal: controller.signal })).resolves.toEqual(accounts);
+        const [url, init] = fetchMock.mock.calls[0] ?? [];
+        expect(url.pathname).toBe("/api/connector/personal-accounts");
+        expect(init?.signal).toBe(controller.signal);
+    });
+    it("surfaces connector API errors through the shared HTTP error contract", async () => {
+        const fetchMock = vi.fn().mockResolvedValue(new Response("connector access denied", {
+            status: 403,
+            statusText: "Forbidden",
+        }));
+        const client = new Client({
+            apiUrl: "https://xpert.example/api/ai",
+            callerOptions: { fetch: fetchMock, maxRetries: 0 },
+        });
+        await expect(client.connectors.runtimeOptions("xpert-1")).rejects.toMatchObject({
+            status: 403,
+            message: expect.stringContaining("connector access denied"),
+        });
+    });
+});
+describe("ConversationsClient workspace files", () => {
+    it("lists the workspace files bound to an encoded conversation id", async () => {
+        const files = [
+            { filePath: "brief.pdf", mimeType: "application/pdf", size: 2048 },
+        ];
+        const fetchMock = vi
+            .fn()
+            .mockResolvedValue(jsonResponse(files));
+        const controller = new AbortController();
+        const client = new Client({
+            apiUrl: "https://xpert.example/api/ai",
+            apiKey: "secret",
+            callerOptions: { fetch: fetchMock },
+        });
+        await expect(client.conversations.listWorkspaceFiles("conversation/1", {
+            depth: 4,
+            signal: controller.signal,
+        })).resolves.toEqual(files);
+        const [url, init] = fetchMock.mock.calls[0] ?? [];
+        expect(url.pathname).toBe("/api/ai/conversations/conversation%2F1/files");
+        expect(url.searchParams.get("deepth")).toBe("4");
+        expect(init?.headers).toMatchObject({ "x-api-key": "secret" });
+        expect(init?.signal).toBe(controller.signal);
+    });
+});
+//# sourceMappingURL=projects-connectors.test.js.map