@sanqianx/claude-ai-workbench 0.11.0

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@sanqianx/claude-ai-workbench",
+  "version": "0.11.0",
+  "description": "Shared Claude Code terminal and Anthropic-compatible AI profile modules for local developer tools.",
+  "type": "commonjs",
+  "main": "src/index.js",
+  "bin": {
+    "claude-workbench": "packages/server/bin/claude-workbench.js",
+    "claude-ai-workbench": "packages/server/bin/claude-workbench.js"
+  },
+  "files": [
+    "packages",
+    "apps",
+    "src",
+    "docs/sdk",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "check": "node scripts/check-package.js",
+    "test": "node --test tests/unit/*.test.js tests/integration/*.test.js tests/contract/*.test.js",
+    "test:real": "node --test tests/real/*.test.js",
+    "start": "node packages/server/bin/claude-workbench-server.js",
+    "start:agent-terminal": "node packages/server/bin/agent-terminal-server.js",
+    "start:test-host": "powershell -NoProfile -ExecutionPolicy Bypass -File scripts/start-test-host.ps1",
+    "sdk:check": "node scripts/validate-sdk.js && tsc -p tsconfig.sdk.json",
+    "sdk:pack": "node scripts/pack-sdk.js",
+    "release:sync": "node scripts/sync-release-version.js",
+    "release:verify": "npm run verify && node scripts/sync-release-version.js --check",
+    "prepublishOnly": "npm run release:verify",
+    "preversion": "npm run release:verify",
+    "version": "node scripts/sync-release-version.js --stage",
+    "postversion": "npm run release:verify",
+    "verify": "npm run check && npm test && npm run sdk:check"
+  },
+  "workspaces": [
+    "packages/*"
+  ],
+  "dependencies": {
+    "@anthropic-ai/claude-agent-sdk": "^0.2.141"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "license": "Apache-2.0",
+  "devDependencies": {
+    "@types/node": "^26.1.1",
+    "typescript": "^7.0.2",
+    "yaml": "^2.9.0"
+  }
+}

package/packages/client/README.md

@@ -0,0 +1,11 @@
+# @claude-ai-workbench/client
+
+浏览器和 Node.js 使用的 HTTP/SSE Client SDK。
+
+```js
+const { createClaudeWorkbenchClient } = require("@claude-ai-workbench/client");
+const client = createClaudeWorkbenchClient({ apiBase: "http://127.0.0.1:5760/api/claude-workbench/v1" });
+const profiles = await client.listProfiles();
+```
+
+浏览器也可直接加载 `index.js`，然后使用全局函数 `createClaudeWorkbenchClient`。

package/packages/client/index.d.ts

@@ -0,0 +1,81 @@
+import type {
+  AgentId,
+  AgentStatus,
+  AiProfile,
+  AiProfileInput,
+  CredentialInput,
+  EffortLevel,
+  HealthResult,
+  PermissionMode,
+  ProfileTestResult,
+  Project,
+  ProjectInput,
+  ProjectPatch,
+  RuntimeInfo,
+  AttachmentInput,
+  SlashCommand,
+  SessionSnapshot,
+  SessionSummary,
+  WorkbenchContext,
+  WorkbenchEvent,
+} from "@claude-ai-workbench/contracts";
+
+export interface RequestOptions { signal?: AbortSignal; [key: string]: unknown; }
+export interface StartSessionOptions extends RequestOptions {
+  permissionMode?: PermissionMode;
+  agentId?: AgentId;
+  effort?: EffortLevel;
+  aiProfileId?: string | null;
+  model?: string | null;
+}
+export interface ListSessionsOptions extends RequestOptions { archived?: boolean; }
+export interface SendOptions { permissionMode?: PermissionMode; [key: string]: unknown; }
+export interface StreamHandlers {
+  onEvent?: (event: WorkbenchEvent) => void;
+  onError?: (error: Error) => void;
+  onOpen?: () => void;
+  afterSequence?: number;
+}
+export interface ClientResourceCounts { streams: number; requests: number; reconnects: number; }
+export interface ClaudeWorkbenchClientOptions {
+  apiBase?: string;
+  fetch?: typeof fetch;
+  EventSource?: typeof EventSource;
+}
+
+export interface ClaudeWorkbenchClient {
+  health(): Promise<HealthResult>;
+  runtime(): Promise<RuntimeInfo>;
+  listAgents(): Promise<AgentStatus[]>;
+  listProjects(): Promise<Project[]>;
+  createProject(project: ProjectInput): Promise<Project>;
+  getProject(id: string): Promise<Project>;
+  renameProject(id: string, name: string): Promise<Project>;
+  updateProject(id: string, patch: ProjectPatch): Promise<Project>;
+  removeProject(id: string): Promise<void>;
+  listProfiles(): Promise<AiProfile[]>;
+  saveProfile(profile: AiProfileInput): Promise<AiProfile>;
+  deleteProfile(id: string): Promise<void>;
+  setCredential(id: string, credential: string | CredentialInput): Promise<void>;
+  testProfile(id: string): Promise<ProfileTestResult>;
+  testProfileDraft(profile: AiProfileInput, credential?: string): Promise<ProfileTestResult>;
+  listSessions(context: WorkbenchContext | string, options?: ListSessionsOptions): Promise<SessionSummary[]>;
+  startSession(context: WorkbenchContext, options?: StartSessionOptions): Promise<SessionSummary>;
+  loadSession(id: string, options?: RequestOptions): Promise<SessionSnapshot>;
+  listCommands(id: string, options?: RequestOptions): Promise<SlashCommand[]>;
+  subscribe(id: string, handlers: StreamHandlers | ((event: WorkbenchEvent) => void), onError?: (error: Error) => void, options?: {afterSequence?: number}): () => void;
+  send(sessionId: string, text: string, options?: SendOptions): Promise<unknown>;
+  send(args: {sessionId: string; text?: string; attachments?: AttachmentInput[]; options?: SendOptions}): Promise<unknown>;
+  resolvePermission(sessionId: string, requestId: string, allow: boolean, message?: string): Promise<unknown>;
+  resolvePermission(args: {sessionId: string; requestId: string; allow: boolean; message?: string}): Promise<unknown>;
+  abort(sessionId: string | {sessionId: string}): Promise<unknown>;
+  setPermissionMode(sessionId: string, mode: PermissionMode): Promise<unknown>;
+  setPermissionMode(args: {sessionId: string; mode: PermissionMode}): Promise<unknown>;
+  archiveSession(sessionId: string | {sessionId: string}): Promise<{sessionId: string; archivedAt: string}>;
+  restoreSession(sessionId: string | {sessionId: string}): Promise<void>;
+  resourceCounts(): ClientResourceCounts;
+  destroy(): void;
+}
+
+export declare const EVENT_TYPES: readonly string[];
+export declare function createClaudeWorkbenchClient(options?: ClaudeWorkbenchClientOptions): ClaudeWorkbenchClient;

package/packages/client/index.js

@@ -0,0 +1,198 @@
+(function (global, factory) {
+  const exported = factory();
+  if (typeof module !== 'undefined' && module.exports) module.exports = exported;
+  global.createClaudeWorkbenchClient = exported.createClaudeWorkbenchClient;
+})(typeof window !== 'undefined' ? window : globalThis, function () {
+  'use strict';
+
+  const EVENT_TYPES = [
+    'workbench/stream-open', 'workbench/stream-reconnecting', 'claude/init', 'claude/state',
+    'claude/session-ready', 'claude/user-prompt', 'claude/system-prompt', 'claude/text-start',
+    'claude/text-delta', 'claude/result', 'claude/thinking-start', 'claude/thinking-delta',
+    'claude/tool-use', 'claude/tool-result', 'claude/permission-request', 'claude/permission-resolved',
+    'claude/usage', 'claude/commands', 'claude/image', 'claude/retry', 'claude/error', 'claude/stderr', 'claude/aborted',
+    'claude/selection-changed',
+  ];
+
+  function createClaudeWorkbenchClient(options = {}) {
+    const apiBase = String(options.apiBase || '/api/claude-workbench/v1').replace(/\/$/, '');
+    const fetchImpl = options.fetch || globalThis.fetch;
+    const EventSourceImpl = options.EventSource || globalThis.EventSource;
+    if (typeof fetchImpl !== 'function') throw new Error('fetch is required');
+    const streams = new Set();
+    const controllers = new Set();
+    let destroyed = false;
+    let reconnects = 0;
+
+    async function request(path, init = {}) {
+      if (destroyed) throw new Error('ClaudeWorkbenchClient is destroyed');
+      const controller = new AbortController();
+      const external = init.signal;
+      const abort = () => controller.abort();
+      if (external) {
+        if (external.aborted) controller.abort();
+        else external.addEventListener('abort', abort, { once: true });
+      }
+      controllers.add(controller);
+      try {
+        const response = await fetchImpl(`${apiBase}${path}`, {
+          ...init,
+          headers: { 'Content-Type': 'application/json', ...(init.headers || {}) },
+          signal: controller.signal,
+        });
+        const text = await response.text();
+        const data = text ? JSON.parse(text) : null;
+        if (!response.ok) {
+          const error = new Error(data && data.error || `HTTP ${response.status}`);
+          error.status = response.status; error.body = data; throw error;
+        }
+        return data;
+      } finally {
+        controllers.delete(controller);
+        if (external) external.removeEventListener('abort', abort);
+      }
+    }
+
+    function subscribe(sessionId, handlers, onError, subscribeOptions = {}) {
+      if (destroyed) throw new Error('ClaudeWorkbenchClient is destroyed');
+      if (typeof EventSourceImpl !== 'function') throw new Error('EventSource is required');
+      const callback = typeof handlers === 'function' ? handlers : handlers && handlers.onEvent;
+      const errorCallback = typeof onError === 'function' ? onError : handlers && handlers.onError;
+      const openCallback = handlers && typeof handlers === 'object' && handlers.onOpen;
+      const after = Number(subscribeOptions.afterSequence || handlers && handlers.afterSequence || 0);
+      const suffix = after > 0 ? `?after=${encodeURIComponent(after)}` : '';
+      const stream = new EventSourceImpl(`${apiBase}/sessions/${encodeURIComponent(sessionId)}/events${suffix}`);
+      streams.add(stream);
+      let closed = false;
+      const deliver = message => {
+        try { callback && callback(JSON.parse(message.data)); }
+        catch (error) { errorCallback && errorCallback(error); }
+      };
+      EVENT_TYPES.forEach(type => stream.addEventListener && stream.addEventListener(type, deliver));
+      stream.onmessage = deliver;
+      stream.onopen = () => { openCallback && openCallback(); };
+      stream.onerror = () => {
+        reconnects += 1;
+        errorCallback && errorCallback(new Error('SSE connection interrupted; EventSource will reconnect'));
+      };
+      const close = () => {
+        if (closed) return; closed = true; streams.delete(stream); stream.close();
+      };
+      return close;
+    }
+
+    const client = {
+      health: () => request('/health'),
+      runtime: () => request('/runtime'),
+      async listAgents() { const result = await request('/agents'); return result.agents || result || []; },
+      async listProjects() { const result = await request('/projects'); return result.projects || result || []; },
+      createProject(project) {
+        return request('/projects', { method: 'POST', body: JSON.stringify(project) });
+      },
+      getProject(id) { return request(`/projects/${encodeURIComponent(id)}`); },
+      renameProject(id, name) {
+        return request(`/projects/${encodeURIComponent(id)}`, { method: 'PATCH', body: JSON.stringify({ name }) });
+      },
+      updateProject(id, patch) {
+        return request(`/projects/${encodeURIComponent(id)}`, { method: 'PATCH', body: JSON.stringify(patch) });
+      },
+      removeProject(id, opts = {}) {
+        const qs = opts.keepSessions ? '?keepSessions=1' : '';
+        return request(`/projects/${encodeURIComponent(id)}${qs}`, { method: 'DELETE' });
+      },
+      async listProfiles() { const result = await request('/profiles'); return result.profiles || result || []; },
+      saveProfile(profile) {
+        const id = encodeURIComponent(profile.id);
+        return request(`/profiles/${id}`, { method: 'PUT', body: JSON.stringify(profile) });
+      },
+      deleteProfile(id) { return request(`/profiles/${encodeURIComponent(id)}`, { method: 'DELETE' }); },
+      setCredential(id, credential) {
+        const payload = typeof credential === 'string' ? { secret: credential } : credential;
+        return request(`/profiles/${encodeURIComponent(id)}/credential`, { method: 'PUT', body: JSON.stringify(payload) });
+      },
+      testProfile(id) { return request(`/profiles/${encodeURIComponent(id)}/test`, { method: 'POST', body: '{}' }); },
+      testProfileDraft(profile, credential = '') {
+        return request('/profiles/test', { method: 'POST', body: JSON.stringify({ profile, credential }) });
+      },
+      detectProfileModels(profile, credential = '') {
+        return request('/profiles/detect-models', { method: 'POST', body: JSON.stringify({ profile, credential }) });
+      },
+      async listSessions(context, opts = {}) {
+        const contextId = context && (context.contextId || context.projectId) || context;
+        const archived = opts.archived === true ? '&archived=1' : '';
+        const result = await request(`/sessions?contextId=${encodeURIComponent(contextId)}${archived}`, opts);
+        return result.sessions || result || [];
+      },
+      startSession(context, opts = {}) {
+        const payloadContext = { ...context, contextId: context.contextId || context.projectId };
+        const result = request('/sessions', {
+          method: 'POST',
+          body: JSON.stringify({
+            context: payloadContext,
+            aiProfileId: opts.aiProfileId !== undefined ? opts.aiProfileId : context.aiProfileId,
+            model: opts.model !== undefined ? opts.model : context.model,
+            permissionMode: opts.permissionMode || 'default',
+            agentId: opts.agentId || undefined,
+            effort: opts.effort || undefined,
+          }),
+          signal: opts.signal,
+        });
+        return result.then(r => r.session || r);
+      },
+      loadSession(id, opts = {}) { return request(`/sessions/${encodeURIComponent(id)}`, opts); },
+      async listCommands(id, opts = {}) {
+        const result = await request(`/sessions/${encodeURIComponent(id)}/commands`, opts);
+        return result.commands || result || [];
+      },
+      subscribe,
+      send(sessionOrArgs, text, opts = {}) {
+        const args = typeof sessionOrArgs === 'object' ? sessionOrArgs : { sessionId: sessionOrArgs, text, options: opts };
+        return request(`/sessions/${encodeURIComponent(args.sessionId)}/input`, {
+          method: 'POST', body: JSON.stringify({ text: args.text || '', attachments: args.attachments || [], options: args.options || {} }),
+        });
+      },
+      resolvePermission(sessionOrArgs, requestId, allow, message) {
+        const args = typeof sessionOrArgs === 'object' ? sessionOrArgs : { sessionId: sessionOrArgs, requestId, allow, message };
+        return request(`/sessions/${encodeURIComponent(args.sessionId)}/permissions/${encodeURIComponent(args.requestId)}/resolve`, {
+          method: 'POST', body: JSON.stringify({ allow: args.allow === true, message: args.message || '' }),
+        });
+      },
+      abort(sessionOrArgs) {
+        const id = typeof sessionOrArgs === 'object' ? sessionOrArgs.sessionId : sessionOrArgs;
+        return request(`/sessions/${encodeURIComponent(id)}/abort`, { method: 'POST', body: '{}' });
+      },
+      setPermissionMode(sessionOrArgs, mode) {
+        const args = typeof sessionOrArgs === 'object' ? sessionOrArgs : { sessionId: sessionOrArgs, mode };
+        return request(`/sessions/${encodeURIComponent(args.sessionId)}/permission-mode`, {
+          method: 'PUT', body: JSON.stringify({ mode: args.mode }),
+        });
+      },
+      updateSessionSelection(sessionOrArgs, selection = {}) {
+        const args = typeof sessionOrArgs === 'object' ? sessionOrArgs : { sessionId: sessionOrArgs, ...selection };
+        return request(`/sessions/${encodeURIComponent(args.sessionId)}/selection`, {
+          method: 'PUT',
+          body: JSON.stringify({ aiProfileId: args.aiProfileId !== undefined ? args.aiProfileId : selection.aiProfileId, model: args.model !== undefined ? args.model : selection.model }),
+        });
+      },
+      archiveSession(sessionOrArgs) {
+        const id = typeof sessionOrArgs === 'object' ? sessionOrArgs.sessionId : sessionOrArgs;
+        return request(`/sessions/${encodeURIComponent(id)}/archive`, { method: 'PUT', body: '{}' });
+      },
+      restoreSession(sessionOrArgs) {
+        const id = typeof sessionOrArgs === 'object' ? sessionOrArgs.sessionId : sessionOrArgs;
+        return request(`/sessions/${encodeURIComponent(id)}/archive`, { method: 'DELETE' });
+      },
+      resourceCounts() { return { streams: streams.size, requests: controllers.size, reconnects }; },
+      destroy() {
+        destroyed = true;
+        for (const stream of streams) try { stream.close(); } catch {}
+        streams.clear();
+        for (const controller of controllers) controller.abort();
+        controllers.clear();
+      },
+    };
+    return client;
+  }
+
+  return { createClaudeWorkbenchClient, EVENT_TYPES };
+});

package/packages/client/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@claude-ai-workbench/client",
+  "version": "0.11.0",
+  "type": "commonjs",
+  "main": "index.js",
+  "browser": "index.js",
+  "types": "index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "browser": "./index.js",
+      "require": "./index.js",
+      "default": "./index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "README.md"
+  ],
+  "dependencies": {
+    "@claude-ai-workbench/contracts": "0.11.0"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "license": "Apache-2.0"
+}

package/packages/contracts/README.md

@@ -0,0 +1,9 @@
+# @claude-ai-workbench/contracts
+
+Claude AI Workbench 的公共数据契约和 TypeScript 类型，等价于传统 SDK 的公共头文件。
+
+```ts
+import type { AiProfile, AiProfileInput, ProfileTestResult } from "@claude-ai-workbench/contracts";
+```
+
+本包不包含运行时服务，也不接触 API Key。

package/packages/contracts/index.d.ts

@@ -0,0 +1,252 @@
+export type PermissionMode = "default" | "acceptEdits" | "plan" | "bypassPermissions";
+export type ProfileProtocol = "anthropic-compatible" | "openai-compatible" | string;
+export type AgentId = "claude-code" | "codex" | "opencode" | "zcode";
+export type EffortLevel = "low" | "medium" | "high" | "max";
+
+export interface AgentCapabilities {
+  thinking: boolean;
+  permissions: boolean;
+  toolStream: boolean;
+  images: boolean;
+  resume: true;
+  modelOverride: boolean;
+  generationParams: readonly string[];
+}
+
+export interface AgentDefinition {
+  id: AgentId;
+  label: string;
+  transport: string;
+  authModes: readonly string[];
+  capabilities: AgentCapabilities;
+}
+
+export interface AgentStatus extends AgentDefinition {
+  capabilities: { generationParams: string[] } & Omit<AgentCapabilities, "generationParams">;
+  available: boolean;
+  version: string | null;
+}
+
+export interface Project {
+  id: string;
+  name: string;
+  rootPath: string;
+  createdAt: string;
+  updatedAt: string;
+  defaultAiProfileId?: string | null;
+  defaultModel?: string | null;
+  defaultAgentId?: AgentId;
+}
+
+export interface ProjectInput {
+  name: string;
+  rootPath: string;
+  defaultAiProfileId?: string | null;
+  defaultModel?: string | null;
+  defaultAgentId?: AgentId;
+}
+
+export type ProjectPatch = Partial<Omit<ProjectInput, "rootPath">>;
+
+export interface ModelListEntry {
+  id: string;
+  openaiId?: string;
+  label: string;
+  tags: string[];
+}
+
+export interface WorkbenchContext {
+  contextId: string;
+  contextType?: string;
+  displayName?: string;
+  workspaceRef?: string;
+  aiProfileId?: string | null;
+  model?: string | null;
+  metadata?: Record<string, unknown>;
+}
+
+export interface AiProfileModels {
+  default: string;
+  fast?: string;
+  reasoning?: string;
+  coding?: string;
+  largeContext?: string;
+  list?: ModelListEntry[];
+  [role: string]: string | undefined | ModelListEntry[];
+}
+
+export interface AiProfileInput {
+  id: string;
+  name?: string;
+  provider: string;
+  protocol?: ProfileProtocol;
+  runtime?: "claude-code";
+  baseUrl: string;
+  openaiBaseUrl?: string;
+  credentialRef?: string;
+  models: AiProfileModels;
+  contextWindow?: number;
+  timeoutMs?: number;
+  permissionMode?: PermissionMode;
+  systemPrompt?: Record<string, unknown> | string;
+  enabled?: boolean;
+}
+
+export interface AiProfile extends AiProfileInput {
+  name: string;
+  protocol: ProfileProtocol;
+  runtime: "claude-code";
+  credentialRef: string;
+  contextWindow: number;
+  timeoutMs: number;
+  permissionMode: PermissionMode;
+  systemPrompt: Record<string, unknown>;
+  enabled: boolean;
+  credentialConfigured?: boolean;
+  credentialMasked?: string;
+}
+
+export interface CredentialInput { secret: string; }
+
+export interface ProfileTestResult {
+  ok: true;
+  runtime: "claude-code";
+  runtimeVerified: true;
+  profileId: string;
+  model: string;
+  firstEventMs: number;
+  durationMs: number;
+  resultPreview: string;
+}
+
+export interface HealthResult {
+  status: "ok";
+  version: string;
+  apiVersion: string;
+  activeProcesses: number;
+  sessions: number;
+  time: string;
+}
+
+export interface RuntimeInfo {
+  runtime: "claude-code";
+  available: boolean;
+  executable: string | null;
+  transport: string;
+}
+
+export interface SessionSummary {
+  sessionId: string;
+  contextId: string;
+  projectId: string;
+  agentId: AgentId;
+  title: string;
+  active: boolean;
+  state: string;
+  model: string | null;
+  aiProfileId: string | null;
+  providerName?: string | null;
+  authSource?: "profile-injected" | "agent-owned";
+  selectedModel?: string | null;
+  permissionMode: PermissionMode;
+  archived: boolean;
+  turns: number;
+  startedAt: string;
+  updatedAt: string;
+  connectionState: string;
+}
+
+export interface WorkbenchEvent {
+  type: string;
+  sessionId: string;
+  contextId: string;
+  sequence: number;
+  at: string;
+  [key: string]: unknown;
+}
+
+export interface ImageAttachmentInput {
+  id?: string;
+  name: string;
+  mediaType: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+  data: string;
+  size?: number;
+  width?: number;
+  height?: number;
+}
+
+export interface ImageAttachment {
+  id: string;
+  name: string;
+  mediaType: ImageAttachmentInput["mediaType"];
+  size: number;
+  width?: number;
+  height?: number;
+  url: string;
+}
+
+export interface TextAttachmentInput {
+  id?: string;
+  name: string;
+  mediaType: "text/plain" | "text/markdown" | "application/json" | "text/csv";
+  data: string;
+  size?: number;
+}
+
+export type AttachmentInput = ImageAttachmentInput | TextAttachmentInput;
+export interface TextAttachment {
+  id: string;
+  name: string;
+  mediaType: TextAttachmentInput["mediaType"];
+  size: number;
+  url: string;
+}
+export type Attachment = ImageAttachment | TextAttachment;
+
+export interface SlashCommand {
+  name: string;
+  description: string;
+  argumentHint?: string;
+  aliases?: string[];
+  source?: string;
+}
+
+export interface SessionSnapshot {
+  session: SessionSummary;
+  events: WorkbenchEvent[];
+  permission: Record<string, unknown> | null;
+  permissionMode: PermissionMode;
+  tokenUsage: Record<string, unknown>;
+}
+
+export declare const API_VERSION: "v1";
+export declare const DEFAULT_API_PREFIX: "/api/claude-workbench/v1";
+export declare const RUNTIME: "claude-code";
+export declare const DEFAULT_AGENT: AgentId;
+export declare const AGENT_IDS: readonly AgentId[];
+export declare const EFFORT_LEVELS: readonly EffortLevel[];
+export declare const AGENTS: Record<AgentId, AgentDefinition>;
+export declare const PERMISSION_MODES: readonly PermissionMode[];
+export declare const IMAGE_MEDIA_TYPES: readonly ImageAttachmentInput["mediaType"][];
+export declare const TEXT_MEDIA_TYPES: readonly TextAttachmentInput["mediaType"][];
+export declare const TEXT_FILE_TYPES: Readonly<Record<string, TextAttachmentInput["mediaType"]>>;
+export declare const MAX_IMAGE_BYTES: number;
+export declare const MAX_IMAGES_PER_MESSAGE: number;
+export declare const MAX_IMAGE_MESSAGE_BYTES: number;
+export declare const MAX_TEXT_BYTES: number;
+export declare const MAX_ATTACHMENTS_PER_MESSAGE: number;
+export declare const MAX_ATTACHMENT_MESSAGE_BYTES: number;
+export declare const EVENT_TYPES: readonly string[];
+export declare function cleanId(value: unknown, field?: string): string;
+export declare function normalizeContext(input: unknown): WorkbenchContext;
+export declare function normalizeProfile(input: unknown, idOverride?: string): AiProfile;
+export declare function normalizeProject(input: unknown, idOverride?: string): Project;
+export declare function normalizeAgentId(value: unknown): AgentId;
+export declare function normalizeEffort(value: unknown): EffortLevel | undefined;
+export declare function normalizeModelEntries(input: unknown): ModelListEntry[];
+export declare function normalizeImageAttachments(input: unknown): Array<ImageAttachmentInput & { size: number }>;
+export declare function normalizeAttachments(input: unknown): Array<AttachmentInput & { size: number }>;
+export declare function appendTextAttachments(text: string, attachments?: AttachmentInput[]): string;
+export declare function resolveOpenAIBaseUrl(profile?: Partial<AiProfileInput>): string;
+export declare function resolveOpenAIModel(profile?: Partial<AiProfileInput> & { mainModel?: string }, model?: string): string;
+export declare function positiveInt(value: unknown, fallback: number): number;