@qredence/fleet 0.7.4 → 0.9.0

package/dist/web/server/chunk-VM3U6PUU.js

@@ -0,0 +1,769 @@
+import {
+  ChatCommandsResponseSchema,
+  ChatMcpDeleteRequestSchema,
+  ChatMcpListResponseSchema,
+  ChatMcpOAuthLoginRequestSchema,
+  ChatMcpOAuthLoginResponseSchema,
+  ChatMcpUpsertRequestSchema,
+  ChatModelsDiscoverRequestSchema,
+  ChatModelsDiscoverResponseSchema,
+  ChatModelsResponseSchema,
+  ChatOpenUIArtifactUpsertRequestSchema,
+  ChatOpenUIArtifactUpsertResponseSchema,
+  ChatPlanPresentationSchema,
+  ChatPlanPresentationUpsertRequestSchema,
+  ChatProviderRemoveRequestSchema,
+  ChatProviderUpdateRequestSchema,
+  ChatProviderUpdateResponseSchema,
+  ChatProvidersResponseSchema,
+  ChatQuestionAnswerResponseSchema,
+  ChatQueueMutationRequestSchema,
+  ChatQueueMutationResponseSchema,
+  ChatResourcesResponseSchema,
+  ChatSessionResponseSchema,
+  ChatSessionsResponseSchema,
+  ChatSettingsResponseSchema,
+  ChatSettingsUpdateRequestSchema,
+  ChatStreamEventSchema,
+  ProjectCreateRequestSchema,
+  ProjectDirectoryBrowseResponseSchema,
+  ProjectListResponseSchema,
+  ProjectRenameRequestSchema,
+  ProjectSummarySchema,
+  SessionTreeNavigateRequestSchema,
+  SessionTreeNavigateResponseSchema,
+  SessionTreeSnapshotResponseSchema,
+  UploadedAttachmentSchema,
+  WorkspaceFileResponseSchema,
+  WorkspaceTreeResponseSchema,
+  external_exports,
+  useMutation,
+  useQuery,
+  useQueryClient
+} from "./chunk-KDCSEISZ.js";
+
+// web/app/dist/server/assets/chat-queries-CyG4XV35.js
+var RUNTIME_API_PREFIXES = [
+  "/api/health",
+  "/api/chat",
+  "/api/projects",
+  "/api/workspace"
+];
+function resolveChatRuntimeBaseUrl() {
+  return "";
+}
+function isChatRuntimePath(path) {
+  return RUNTIME_API_PREFIXES.some((prefix) => path === prefix || path.startsWith(`${prefix}?`) || path.startsWith(`${prefix}/`));
+}
+function resolveChatApiUrl(path) {
+  const base = resolveChatRuntimeBaseUrl();
+  if (!base) return path;
+  const [pathname] = path.split("?");
+  if (!isChatRuntimePath(pathname)) return path;
+  return `${base}${path}`;
+}
+var ChatStreamContractError = class extends Error {
+  constructor() {
+    super("The chat stream received an invalid event. The response may still be running; reload the conversation to refresh it.");
+    this.name = "ChatStreamContractError";
+  }
+};
+var ChatRequestError = class extends Error {
+  status;
+  body;
+  code;
+  remediation;
+  constructor(status, body) {
+    super(formatChatRequestErrorMessage(status, body));
+    this.name = "ChatRequestError";
+    this.status = status;
+    this.body = body;
+    const envelope = parseErrorEnvelope(body);
+    this.code = envelope?.code;
+    this.remediation = envelope?.remediation;
+  }
+};
+function isFleetErrorRemediation(value) {
+  return typeof value === "object" && value !== null && typeof value.action === "string" && typeof value.label === "string";
+}
+function parseErrorEnvelope(body) {
+  const trimmed = body.trim();
+  if (!trimmed) return null;
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (typeof parsed.code === "string") return {
+      code: parsed.code,
+      remediation: isFleetErrorRemediation(parsed.remediation) ? parsed.remediation : void 0
+    };
+  } catch {
+  }
+  return null;
+}
+function formatChatRequestErrorMessage(status, body) {
+  const trimmed = body.trim();
+  if (!trimmed) return `Request failed (${status})`;
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (typeof parsed.message === "string" && parsed.message.length > 0) return parsed.message;
+  } catch {
+  }
+  return trimmed;
+}
+function isForbiddenSessionError(error) {
+  return (error instanceof ChatRequestError ? error.body : error instanceof Error ? error.message : String(error)).includes("Session belongs to another user");
+}
+function isUnknownSessionError(error) {
+  return error instanceof ChatRequestError && error.status === 404;
+}
+function isDaemonDisconnectError(error) {
+  if (!(error instanceof Error)) return false;
+  if (error.code === "NETWORK_DISCONNECTED") return true;
+  return /daemon is not connected/i.test(error.message) || /cannot send daemon command/i.test(error.message);
+}
+function chatErrorFromStreamEvent(event) {
+  const error = new Error(event.message);
+  if (event.code) error.code = event.code;
+  return error;
+}
+async function fetchJson(url, init) {
+  const resolvedUrl = resolveChatApiUrl(url);
+  const headers = new Headers(init?.headers);
+  const response = await fetch(resolvedUrl, {
+    ...init,
+    headers
+  });
+  if (!response.ok) {
+    const body = await response.text();
+    throw new ChatRequestError(response.status, body);
+  }
+  return await response.json();
+}
+async function fetchValidatedJson(url, schema, init) {
+  return parseWithSchema(schema, await fetchJson(url, init), `Response from ${url}`);
+}
+async function readChatStream(response, onEvent) {
+  const reader = response.body?.getReader();
+  if (!reader) throw new Error("Chat response did not include a stream");
+  const decoder = new TextDecoder();
+  let buffer = "";
+  const expectedSequenceNumbers = /* @__PURE__ */ new Map();
+  function trackSequence(sessionId, eventType, seq) {
+    const current = expectedSequenceNumbers.get(`${sessionId}:${eventType}`) ?? 0;
+    if (seq > current + 1) console.warn(`[chat-sequence] Gap detected in ${eventType} sequence for session ${sessionId}: expected ${current + 1}, got ${seq}`);
+    expectedSequenceNumbers.set(`${sessionId}:${eventType}`, seq);
+  }
+  const handleLine = (line) => {
+    const trimmed = line.trim();
+    if (!trimmed) return;
+    let data;
+    try {
+      data = JSON.parse(trimmed);
+    } catch {
+      console.error('[chat-stream] Invalid NDJSON event {"type":"unknown","issues":["invalid_json:[root]"]}');
+      throw new ChatStreamContractError();
+    }
+    const eventType = typeof data === "object" && data !== null ? "type" in data && data.type : void 0;
+    const sessionId = typeof data === "object" && data !== null && "sessionId" in data ? String(data.sessionId) : void 0;
+    const sequenceNumber = typeof data === "object" && data !== null && "sequenceNumber" in data ? Number(data.sequenceNumber) : void 0;
+    if (eventType === "start" || eventType === "done" || eventType === "error" || eventType === "plan" || eventType === "state" || eventType === "tool" || eventType === "queue" || eventType === "reasoning" || eventType === "reasoning_text" || eventType === "compaction" || eventType === "retry" || eventType === "payload" || eventType === "session_snapshot") {
+      const validatedEvent = parseWithSchema(ChatStreamEventSchema, data, "Chat stream event");
+      if (sessionId && sequenceNumber !== void 0) trackSequence(sessionId, String(validatedEvent.type), sequenceNumber);
+      onEvent(validatedEvent);
+    } else onEvent(data);
+  };
+  try {
+    for (; ; ) {
+      const { value, done } = await reader.read();
+      if (done) break;
+      const chunk = decoder.decode(value, { stream: true });
+      buffer += chunk;
+      let newlineIndex = buffer.indexOf("\n");
+      while (newlineIndex >= 0) {
+        handleLine(buffer.slice(0, newlineIndex));
+        buffer = buffer.slice(newlineIndex + 1);
+        newlineIndex = buffer.indexOf("\n");
+      }
+    }
+    buffer += decoder.decode();
+    handleLine(buffer);
+  } catch (error) {
+    await reader.cancel().catch(() => void 0);
+    throw error;
+  } finally {
+    reader.releaseLock();
+  }
+}
+function parseWithSchema(schema, data, label) {
+  const parsed = schema.safeParse(data);
+  if (parsed.success) return parsed.data;
+  if (label === "Chat stream event" || label === "Subagent chat stream event") {
+    const knownTypes = /* @__PURE__ */ new Set([
+      "start",
+      "done",
+      "error",
+      "plan",
+      "state",
+      "tool",
+      "queue",
+      "reasoning",
+      "reasoning_text",
+      "compaction",
+      "retry",
+      "payload",
+      "session_snapshot",
+      "delta",
+      "message",
+      "thinking",
+      "presentation",
+      "rlm"
+    ]);
+    const knownFields = /* @__PURE__ */ new Set([
+      "type",
+      "part",
+      "message",
+      "messages",
+      "parts",
+      "id",
+      "role",
+      "text",
+      "state",
+      "name",
+      "phase",
+      "status",
+      "sessionId",
+      "runId",
+      "messageId",
+      "toolCallId",
+      "toolName",
+      "input",
+      "output",
+      "result",
+      "error",
+      "code",
+      "presentation",
+      "revision",
+      "sequenceNumber",
+      "contentIndex",
+      "terminal",
+      "session",
+      "queue",
+      "payload",
+      "category",
+      "reasoning",
+      "steps",
+      "durationMs",
+      "createdAt",
+      "requestKind",
+      "data",
+      "content"
+    ]);
+    const summarize = (issues, prefix = []) => issues.flatMap((issue) => {
+      const issuePath = [...prefix, ...issue.path ?? []];
+      if (issue.code === "invalid_union" && issue.errors) return issue.errors.filter((branch) => !branch.some((entry) => entry.code === "invalid_value" && entry.path?.[0] === "type")).flatMap((branch) => summarize(branch, issuePath));
+      const path = issuePath.map((key) => typeof key === "number" ? "[]" : typeof key === "string" && knownFields.has(key) ? key : "[field]").join(".");
+      return [`${issue.code ?? "invalid"}:${path || "[root]"}`];
+    });
+    const eventType = typeof data === "object" && data !== null && "type" in data && typeof data.type === "string" && knownTypes.has(data.type) ? data.type : "unknown";
+    console.error(`[chat-stream] Invalid event ${JSON.stringify({
+      type: eventType,
+      issues: summarize(parsed.error.issues).slice(0, 12)
+    })}`);
+    throw new ChatStreamContractError();
+  }
+  throw new Error(`${label} did not match the expected contract`);
+}
+function metadataUrl(metadata) {
+  const params = new URLSearchParams();
+  if (metadata.sessionId) params.set("sessionId", metadata.sessionId);
+  if (metadata.projectId) params.set("projectId", metadata.projectId);
+  if (metadata.openUI) params.set("openUI", "true");
+  return params.toString();
+}
+function labelForState(state) {
+  switch (state) {
+    case "agent_start":
+      return "Working";
+    case "turn_start":
+      return "Waiting";
+    case "message_start":
+      return "Thinking";
+    case "message_end":
+      return "Writing";
+    case "tool_start":
+    case "tool_execution_start":
+    case "tool_execution":
+      return "Executing";
+    case "tool_end":
+    case "tool_execution_end":
+      return "Writing";
+    case "turn_end":
+      return "Turn finished";
+    case "agent_end":
+      return;
+    default:
+      return;
+  }
+}
+var ProjectResponseSchema = external_exports.object({ project: ProjectSummarySchema });
+var chatClient = {
+  async abortSession(metadata) {
+    await fetchJson("/api/chat/abort", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(metadata)
+    });
+  },
+  async answerQuestion(request) {
+    return fetchValidatedJson("/api/chat/question", ChatQuestionAnswerResponseSchema, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(request)
+    });
+  },
+  async mutateQueuedMessage(request) {
+    const body = ChatQueueMutationRequestSchema.parse(request);
+    return fetchValidatedJson("/api/chat/session", ChatQueueMutationResponseSchema, {
+      method: "PATCH",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    });
+  },
+  async deleteQueuedMessage(request) {
+    return this.mutateQueuedMessage({
+      ...request,
+      mutation: request.mutation ?? { type: "delete" }
+    });
+  },
+  async createSession(projectId, signal) {
+    return fetchValidatedJson("/api/chat/new", ChatSessionResponseSchema, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        openUI: true,
+        ...projectId ? { projectId } : {}
+      }),
+      signal
+    });
+  },
+  async listProjects() {
+    return fetchValidatedJson("/api/projects", ProjectListResponseSchema);
+  },
+  async createProject(request) {
+    const body = ProjectCreateRequestSchema.parse(request);
+    return (await fetchValidatedJson("/api/projects", ProjectResponseSchema, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    })).project;
+  },
+  async renameProject(projectId, name) {
+    const body = ProjectRenameRequestSchema.parse({ name });
+    return (await fetchValidatedJson(`/api/projects?projectId=${encodeURIComponent(projectId)}`, ProjectResponseSchema, {
+      method: "PATCH",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    })).project;
+  },
+  async unregisterProject(projectId) {
+    return (await fetchValidatedJson(`/api/projects?projectId=${encodeURIComponent(projectId)}`, ProjectResponseSchema, { method: "DELETE" })).project;
+  },
+  async browseProjectDirectories(options) {
+    const params = new URLSearchParams();
+    if (options?.path) params.set("path", options.path);
+    if (options?.token) params.set("token", options.token);
+    const query = params.toString();
+    return fetchValidatedJson(`/api/projects/browse${query ? `?${query}` : ""}`, ProjectDirectoryBrowseResponseSchema);
+  },
+  async getModels(options) {
+    const params = new URLSearchParams();
+    if (options?.scope === "all") params.set("scope", "all");
+    if (options?.projectId) params.set("projectId", options.projectId);
+    const query = params.toString();
+    return fetchValidatedJson(`/api/chat/models${query ? `?${query}` : ""}`, ChatModelsResponseSchema);
+  },
+  async discoverModels(request) {
+    return fetchValidatedJson("/api/chat/models/discover", ChatModelsDiscoverResponseSchema, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(ChatModelsDiscoverRequestSchema.parse(request))
+    });
+  },
+  async getResources(projectId) {
+    return fetchValidatedJson(`/api/chat/resources${projectId ? `?projectId=${encodeURIComponent(projectId)}` : ""}`, ChatResourcesResponseSchema);
+  },
+  async getCommands(projectId) {
+    return fetchValidatedJson(`/api/chat/commands${projectId ? `?projectId=${encodeURIComponent(projectId)}` : ""}`, ChatCommandsResponseSchema);
+  },
+  async getSettings(projectId) {
+    return fetchValidatedJson(`/api/chat/settings${projectId ? `?projectId=${encodeURIComponent(projectId)}` : ""}`, ChatSettingsResponseSchema);
+  },
+  async getWorkspaceTree(projectId) {
+    return fetchValidatedJson(`/api/workspace/tree${projectId ? `?projectId=${encodeURIComponent(projectId)}` : ""}`, WorkspaceTreeResponseSchema);
+  },
+  async getWorkspaceFile(path, projectId, signal) {
+    const params = new URLSearchParams({ path });
+    if (projectId) params.set("projectId", projectId);
+    return fetchValidatedJson(`/api/workspace/file?${params}`, WorkspaceFileResponseSchema, signal ? { signal } : void 0);
+  },
+  async listSessions(projectId) {
+    return (await fetchValidatedJson(`/api/chat/sessions${projectId ? `?projectId=${encodeURIComponent(projectId)}` : ""}`, ChatSessionsResponseSchema)).sessions;
+  },
+  async renameSession(sessionId, title) {
+    await fetchJson("/api/chat/sessions", {
+      method: "PATCH",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        sessionId,
+        title
+      })
+    });
+  },
+  async deleteSession(sessionId) {
+    await fetchJson("/api/chat/sessions", {
+      method: "DELETE",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ sessionId })
+    });
+  },
+  async uploadAttachments(sessionId, files) {
+    const form = new FormData();
+    form.set("sessionId", sessionId);
+    for (const file of files) form.append("files", file);
+    const response = await fetch(resolveChatApiUrl("/api/chat/session"), {
+      method: "POST",
+      body: form
+    });
+    if (!response.ok) throw new ChatRequestError(response.status, await response.text());
+    return external_exports.object({ attachments: external_exports.array(UploadedAttachmentSchema) }).parse(await response.json()).attachments;
+  },
+  async getSessionTree(sessionId) {
+    return fetchValidatedJson(`/api/chat/session-tree?${new URLSearchParams({ sessionId })}`, SessionTreeSnapshotResponseSchema).then((response) => response.snapshot);
+  },
+  async navigateSessionTree(request) {
+    const body = SessionTreeNavigateRequestSchema.parse(request);
+    return fetchValidatedJson("/api/chat/session-tree", SessionTreeNavigateResponseSchema, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    }).then((response) => response.snapshot);
+  },
+  async loadSession(metadata) {
+    return fetchValidatedJson(`/api/chat/session?${metadataUrl({
+      ...metadata,
+      openUI: true
+    })}`, ChatSessionResponseSchema);
+  },
+  async loadSubagentSession(parentSessionId, childId) {
+    return fetchValidatedJson(`/api/chat/session?${new URLSearchParams({
+      parentSessionId,
+      childId
+    })}`, ChatSessionResponseSchema);
+  },
+  openSubagentEvents(parentSessionId, childId, resume) {
+    const params = new URLSearchParams({
+      parentSessionId,
+      childId
+    });
+    if (resume?.streamGeneration) params.set("streamGeneration", resume.streamGeneration);
+    if (resume?.lastEventId && resume.lastEventId > 0) params.set("lastEventId", String(resume.lastEventId));
+    return resolveChatApiUrl(`/api/chat/events?${params}`);
+  },
+  async upsertPlanPresentation(request) {
+    const body = ChatPlanPresentationUpsertRequestSchema.parse(request);
+    return fetchValidatedJson("/api/chat/session", external_exports.object({ presentation: ChatPlanPresentationSchema }), {
+      method: "PUT",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    }).then((result) => result.presentation);
+  },
+  async upsertOpenUIArtifact(request) {
+    const body = ChatOpenUIArtifactUpsertRequestSchema.parse(request);
+    return fetchValidatedJson("/api/chat/artifacts", ChatOpenUIArtifactUpsertResponseSchema, {
+      method: "PUT",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    });
+  },
+  async resumeSession(metadata) {
+    return fetchValidatedJson("/api/chat/resume", ChatSessionResponseSchema, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        ...metadata,
+        openUI: true
+      })
+    });
+  },
+  async updateSettings(request, projectId) {
+    const body = ChatSettingsUpdateRequestSchema.parse(request);
+    return fetchValidatedJson(`/api/chat/settings${projectId ? `?projectId=${encodeURIComponent(projectId)}` : ""}`, ChatSettingsResponseSchema, {
+      method: "PATCH",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    });
+  },
+  async streamMessage(request, onEvent, signal) {
+    const response = await fetch(resolveChatApiUrl("/api/chat"), {
+      method: "POST",
+      headers: new Headers({ "Content-Type": "application/json" }),
+      body: JSON.stringify(request),
+      signal
+    });
+    if (!response.ok) {
+      const body = await response.text();
+      throw new ChatRequestError(response.status, body);
+    }
+    await readChatStream(response, onEvent);
+  },
+  async getMcpConnections() {
+    return fetchValidatedJson("/api/chat/mcp", ChatMcpListResponseSchema);
+  },
+  async upsertMcpConnection(request) {
+    const body = ChatMcpUpsertRequestSchema.parse(request);
+    return fetchValidatedJson("/api/chat/mcp", ChatMcpListResponseSchema, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    });
+  },
+  async removeMcpConnection(request) {
+    const body = ChatMcpDeleteRequestSchema.parse(request);
+    return fetchValidatedJson("/api/chat/mcp", ChatMcpListResponseSchema, {
+      method: "DELETE",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    });
+  },
+  async mcpOAuth(request) {
+    const body = ChatMcpOAuthLoginRequestSchema.parse(request);
+    return fetchValidatedJson("/api/chat/mcp/oauth", ChatMcpOAuthLoginResponseSchema, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    });
+  },
+  async getProviders() {
+    return fetchValidatedJson("/api/chat/providers", ChatProvidersResponseSchema);
+  },
+  async updateProvider(request) {
+    const body = ChatProviderUpdateRequestSchema.parse(request);
+    return fetchValidatedJson("/api/chat/providers", ChatProviderUpdateResponseSchema, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    });
+  },
+  async removeProvider(request) {
+    const body = ChatProviderRemoveRequestSchema.parse(request);
+    return fetchValidatedJson("/api/chat/providers", ChatProviderUpdateResponseSchema, {
+      method: "DELETE",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    });
+  }
+};
+var chatQueryKeys = {
+  models: (projectId) => [
+    "chat",
+    "models",
+    projectId ?? "default"
+  ],
+  modelCatalog: (projectId) => [
+    "chat",
+    "models",
+    "catalog",
+    projectId ?? "default"
+  ],
+  providers: ["chat", "providers"],
+  mcp: ["chat", "mcp"],
+  resources: (projectId) => [
+    "chat",
+    "resources",
+    projectId ?? "default"
+  ],
+  commands: (projectId) => [
+    "chat",
+    "commands",
+    projectId ?? "default"
+  ],
+  settings: (projectId) => [
+    "chat",
+    "settings",
+    projectId ?? "default"
+  ],
+  workspace: (projectId) => [
+    "workspace",
+    "tree",
+    projectId ?? "default"
+  ],
+  projects: ["projects"]
+};
+var keys = chatQueryKeys;
+function useChatModels(projectId) {
+  return useQuery({
+    queryKey: keys.models(projectId),
+    queryFn: () => chatClient.getModels({ projectId }),
+    enabled: Boolean(projectId)
+  });
+}
+function useChatProjects() {
+  return useQuery({
+    queryKey: keys.projects,
+    queryFn: () => chatClient.listProjects(),
+    staleTime: 5e3
+  });
+}
+function useChatModelCatalog(options) {
+  return useQuery({
+    queryKey: keys.modelCatalog(options?.projectId),
+    queryFn: () => chatClient.getModels({
+      scope: "all",
+      projectId: options?.projectId
+    }),
+    enabled: Boolean(options?.projectId) && options?.enabled !== false
+  });
+}
+function useDiscoverChatModels() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (providerId) => chatClient.discoverModels({ providerId }),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["chat", "models"] });
+    }
+  });
+}
+function useChatResources(projectId) {
+  return useQuery({
+    queryKey: keys.resources(projectId),
+    queryFn: () => chatClient.getResources(projectId),
+    enabled: Boolean(projectId)
+  });
+}
+function useChatCommands(projectId) {
+  return useQuery({
+    queryKey: keys.commands(projectId),
+    queryFn: () => chatClient.getCommands(projectId),
+    enabled: Boolean(projectId)
+  });
+}
+function useChatSettings(projectId) {
+  return useQuery({
+    queryKey: keys.settings(projectId),
+    queryFn: () => chatClient.getSettings(projectId),
+    enabled: Boolean(projectId)
+  });
+}
+function useUpdateChatSettings() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (input) => chatClient.updateSettings(input.request, input.projectId),
+    onSuccess: (settings, input) => {
+      queryClient.setQueryData(keys.settings(input.projectId), settings);
+      queryClient.invalidateQueries({ queryKey: ["chat", "models"] });
+      queryClient.invalidateQueries({ queryKey: ["chat", "resources"] });
+      queryClient.invalidateQueries({ queryKey: ["chat", "commands"] });
+    }
+  });
+}
+function useWorkspaceTree(projectId, options) {
+  return useQuery({
+    queryKey: keys.workspace(projectId),
+    queryFn: () => chatClient.getWorkspaceTree(projectId),
+    enabled: Boolean(projectId) && options?.enabled !== false
+  });
+}
+function useChatMcpConnections() {
+  return useQuery({
+    queryKey: keys.mcp,
+    queryFn: () => chatClient.getMcpConnections()
+  });
+}
+function useUpdateMcpConnection() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (request) => chatClient.upsertMcpConnection(request),
+    onSuccess: (data) => {
+      queryClient.setQueryData(keys.mcp, data);
+      queryClient.invalidateQueries({ queryKey: ["chat", "resources"] });
+    }
+  });
+}
+function useRemoveMcpConnection() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (request) => chatClient.removeMcpConnection(request),
+    onSuccess: (data) => {
+      queryClient.setQueryData(keys.mcp, data);
+      queryClient.invalidateQueries({ queryKey: ["chat", "resources"] });
+    }
+  });
+}
+function useMcpOAuth() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (request) => chatClient.mcpOAuth(request),
+    onSuccess: (data) => {
+      if (data.status !== "success" || !data.connections) return;
+      queryClient.setQueryData(keys.mcp, { connections: data.connections });
+      queryClient.invalidateQueries({ queryKey: ["chat", "resources"] });
+    }
+  });
+}
+function useChatProviders() {
+  return useQuery({
+    queryKey: keys.providers,
+    queryFn: () => chatClient.getProviders()
+  });
+}
+function useUpdateChatProvider() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (request) => chatClient.updateProvider(request),
+    onSuccess: (data) => {
+      queryClient.setQueryData(keys.providers, { providers: data.providers });
+      queryClient.invalidateQueries({ queryKey: ["chat", "models"] });
+      queryClient.invalidateQueries({ queryKey: ["chat", "settings"] });
+    }
+  });
+}
+function useRemoveChatProvider() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (request) => chatClient.removeProvider(request),
+    onSuccess: (data) => {
+      queryClient.setQueryData(keys.providers, { providers: data.providers });
+      queryClient.invalidateQueries({ queryKey: ["chat", "models"] });
+      queryClient.invalidateQueries({ queryKey: ["chat", "settings"] });
+    }
+  });
+}
+
+export {
+  resolveChatApiUrl,
+  ChatStreamContractError,
+  isForbiddenSessionError,
+  isUnknownSessionError,
+  isDaemonDisconnectError,
+  chatErrorFromStreamEvent,
+  fetchJson,
+  parseWithSchema,
+  labelForState,
+  chatClient,
+  chatQueryKeys,
+  useChatModels,
+  useChatProjects,
+  useChatModelCatalog,
+  useDiscoverChatModels,
+  useChatResources,
+  useChatCommands,
+  useChatSettings,
+  useUpdateChatSettings,
+  useWorkspaceTree,
+  useChatMcpConnections,
+  useUpdateMcpConnection,
+  useRemoveMcpConnection,
+  useMcpOAuth,
+  useChatProviders,
+  useUpdateChatProvider,
+  useRemoveChatProvider
+};