@pstdio/sdk 0.7.0 → 0.9.0

package/dist/client/index.js

@@ -1,12 +1,3 @@
-// src/client/actions.ts
-var createActionClient = (request) => ({
-  list: (projectId, targetType) => request(targetType ? `/v1/projects/${projectId}/actions?targetType=${targetType}` : `/v1/projects/${projectId}/actions`),
-  execute: (projectId, actionKey, input) => request(`/v1/projects/${projectId}/actions/${encodeURIComponent(actionKey)}/execute`, {
-    method: "POST",
-    body: input
-  })
-});
-
 // src/client/agents.ts
 var createAgentClient = (request) => ({
   list: () => request("/v1/agents"),
@@ -62,8 +53,6 @@ var createProjectClient = (request) => ({
     const query = params.toString();
     return request(`/v1/projects/${projectId}/activity${query ? `?${query}` : ""}`);
   },
-  listPlugins: (projectId) => request(`/v1/projects/${projectId}/plugins`),
-  registerPlugins: (projectId) => request(`/v1/projects/${projectId}/plugins/register`, { method: "POST" }),
   listRepos: (projectId) => request(`/v1/projects/${projectId}/repos`),
   registerRepo: (projectId, input) => request(`/v1/projects/${projectId}/repos`, { method: "POST", body: input }),
   removeRepo: (projectId, repoId) => request(`/v1/projects/${projectId}/repos/${repoId}`, { method: "DELETE" })
@@ -107,20 +96,32 @@ ${hookOutput}` : message;
   }
   return `Request failed: ${status}`;
 };
+var resolveBaseUrl = (options) => options.baseUrl ?? (typeof process !== "undefined" ? process.env.PSTDIO_API_URL : undefined) ?? "http://localhost:19840";
+var resolveClientUrl = (baseUrl, path) => path.startsWith("http://") || path.startsWith("https://") ? path : `${baseUrl}${path}`;
+var resolveFetch = (options) => options.fetch ?? globalThis.fetch;
+var createRequestHeaders = (options, reqOpts = {}) => {
+  const headers = new Headers(reqOpts.headers);
+  if (reqOpts.hasJsonBody && !headers.has("content-type"))
+    headers.set("content-type", "application/json");
+  if (options.token)
+    headers.set("authorization", `Bearer ${options.token}`);
+  return headers;
+};
 var createRequest = (options) => {
-  const baseUrl = options.baseUrl ?? (typeof process !== "undefined" ? process.env.PSTDIO_API_URL : undefined) ?? "http://localhost:19840";
-  const fetchFn = options.fetch ?? globalThis.fetch;
+  const baseUrl = resolveBaseUrl(options);
+  const fetchFn = resolveFetch(options);
   return async (path, reqOpts = {}) => {
-    const headers = {};
-    if (reqOpts.body !== undefined)
-      headers["content-type"] = "application/json";
-    if (options.token)
-      headers.authorization = `Bearer ${options.token}`;
-    const response = await fetchFn(`${baseUrl}${path}`, {
+    const headers = createRequestHeaders(options, {
+      headers: reqOpts.headers,
+      hasJsonBody: reqOpts.body !== undefined
+    });
+    const url = resolveClientUrl(baseUrl, path);
+    const response = await fetchFn(url, {
       method: reqOpts.method ?? "GET",
-      headers,
+      headers: Object.fromEntries(headers.entries()),
       body: reqOpts.body !== undefined ? JSON.stringify(reqOpts.body) : undefined,
-      signal: reqOpts.signal
+      signal: reqOpts.signal,
+      cache: reqOpts.cache
     });
     if (!response.ok) {
       const errorBody = await response.json().catch(() => null);
@@ -133,8 +134,105 @@ var createRequest = (options) => {
   };
 };
 
+// src/client/sse.ts
+var parseSseEvent = (part) => {
+  let event = "message";
+  const data = [];
+  for (const line of part.split(`
+`)) {
+    if (line.startsWith("event: ")) {
+      event = line.slice(7);
+      continue;
+    }
+    if (line.startsWith("data: ")) {
+      data.push(line.slice(6));
+    }
+  }
+  if (!event || data.length === 0)
+    return null;
+  return { event, data: data.join(`
+`) };
+};
+var consumeSseBuffer = (buffer) => {
+  const parts = buffer.split(`
+
+`);
+  const remainder = parts.pop() ?? "";
+  const events = parts.map((part) => parseSseEvent(part)).filter((event) => event !== null);
+  return { remainder, events };
+};
+var readSseStream = async (body, onEvent, options = {}) => {
+  const reader = body.getReader();
+  const decoder = new TextDecoder;
+  let buffer = "";
+  const abort = () => {
+    reader.cancel();
+  };
+  options.signal?.addEventListener("abort", abort, { once: true });
+  try {
+    while (!options.signal?.aborted) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      buffer += decoder.decode(value, { stream: true });
+      const { remainder, events } = consumeSseBuffer(buffer);
+      buffer = remainder;
+      for (const event of events) {
+        onEvent(event);
+      }
+    }
+  } finally {
+    options.signal?.removeEventListener("abort", abort);
+  }
+};
+
 // src/client/sessions.ts
-var createSessionClient = (request) => ({
+var buildSessionsQuery = (projectId, input = {}) => {
+  const params = new URLSearchParams({ project_id: projectId });
+  if (input.status)
+    params.append("status", input.status);
+  if (input.agent)
+    params.append("agent", input.agent);
+  if (input.archived)
+    params.append("archived", "true");
+  return params.toString();
+};
+var buildSessionStreamPath = (sessionId, attempt) => {
+  const path = `/v1/sessions/${sessionId}/stream`;
+  return attempt === undefined ? path : `${path}?attempt=${attempt}`;
+};
+var parseEventData = (data) => {
+  if (data.length === 0)
+    return null;
+  return JSON.parse(data);
+};
+var streamSessionEvents = async (clientOptions, path, onEvent, options = {}) => {
+  const response = await resolveFetch(clientOptions)(resolveClientUrl(resolveBaseUrl(clientOptions), path), {
+    headers: Object.fromEntries(createRequestHeaders(clientOptions).entries()),
+    signal: options.signal
+  });
+  if (!response.ok || !response.body)
+    throw new Error(`Connection failed: ${response.status}`);
+  await readSseStream(response.body, onEvent, { signal: options.signal });
+};
+var dispatchSessionStreamEvent = (event, handlers) => {
+  if (event.event === "ready") {
+    handlers.onReady?.(parseEventData(event.data));
+    return;
+  }
+  if (event.event === "patch") {
+    handlers.onPatch?.(parseEventData(event.data));
+    return;
+  }
+  if (event.event === "approval_request") {
+    handlers.onApprovalRequest?.(parseEventData(event.data));
+    return;
+  }
+  if (event.event === "end") {
+    handlers.onEnd?.(parseEventData(event.data));
+  }
+};
+var createSessionClient = (request, clientOptions) => ({
   listActivity: (sessionId, input = {}) => {
     const params = new URLSearchParams;
     if (input.event_type)
@@ -150,7 +248,7 @@ var createSessionClient = (request) => ({
     const query = params.toString();
     return request(`/v1/sessions/${sessionId}/activity${query ? `?${query}` : ""}`);
   },
-  list: (projectId) => request(`/v1/sessions?project_id=${projectId}`),
+  list: (projectId, input) => request(`/v1/sessions?${buildSessionsQuery(projectId, input)}`),
   get: (sessionId) => request(`/v1/sessions/${sessionId}`),
   create: (input) => request("/v1/sessions", { method: "POST", body: input }),
   archive: (sessionId) => request(`/v1/sessions/${sessionId}/archive`, { method: "POST" }),
@@ -158,7 +256,29 @@ var createSessionClient = (request) => ({
   approve: (sessionId, input) => request(`/v1/sessions/${sessionId}/approve`, { method: "POST", body: input }),
   getConversation: (sessionId) => request(`/v1/sessions/${sessionId}/conversation`),
   resolveSessionId: (input) => request("/v1/sessions/resolve-session-id", { method: "POST", body: input }),
-  updateStatus: (sessionId, status) => request(`/v1/sessions/${sessionId}/status`, { method: "PATCH", body: { status } })
+  updateStatus: (sessionId, status) => request(`/v1/sessions/${sessionId}/status`, { method: "PATCH", body: { status } }),
+  stream: (sessionId, onEvent, options = {}) => streamSessionEvents(clientOptions, buildSessionStreamPath(sessionId), onEvent, options),
+  connectStream: (sessionId, handlers, options = {}) => {
+    const abortController = new AbortController;
+    let closed = false;
+    streamSessionEvents(clientOptions, buildSessionStreamPath(sessionId, options.attempt), (event) => dispatchSessionStreamEvent(event, handlers), { signal: abortController.signal }).catch((error) => {
+      if (closed || error.name === "AbortError")
+        return;
+      handlers.onError?.(error);
+    });
+    return {
+      close: () => {
+        closed = true;
+        abortController.abort();
+      }
+    };
+  }
+});
+
+// src/client/settings.ts
+var createSettingsClient = (request) => ({
+  get: () => request("/v1/settings"),
+  update: (input) => request("/v1/settings", { method: "PATCH", body: input })
 });
 
 // src/client/skills.ts
@@ -181,6 +301,137 @@ var createStatusClient = (request) => ({
   deleteAttemptStatus: (projectId, statusId) => request(`/v1/projects/${projectId}/attempt-statuses/${statusId}`, { method: "DELETE" })
 });
 
+// src/client/sync.ts
+var DEFAULT_HEARTBEAT_INTERVAL_MS = 1e4;
+var DEFAULT_HEARTBEAT_THRESHOLD = 3;
+var DEFAULT_RECONNECT_DELAY_MS = 1000;
+var parseSyncDeleteEvent = (data) => {
+  const parsed = JSON.parse(data);
+  const id = parsed.id ?? parsed.data?.id;
+  if (!id) {
+    throw new Error("Missing id in sync:delete event.");
+  }
+  return {
+    table: parsed.table,
+    id,
+    seq: parsed.seq
+  };
+};
+var applySyncEvent = (event, data, writers) => {
+  if (event === "init") {
+    const parsed = JSON.parse(data);
+    for (const [table, rows] of Object.entries(parsed.tables)) {
+      writers.getWriter(table)?.truncateAndWrite(rows);
+    }
+    return parsed.seq;
+  }
+  if (event === "sync:set") {
+    const parsed = JSON.parse(data);
+    writers.getWriter(parsed.table)?.upsert(parsed.data);
+    return parsed.seq;
+  }
+  if (event === "sync:delete") {
+    const parsed = parseSyncDeleteEvent(data);
+    writers.getWriter(parsed.table)?.remove(parsed.id);
+    return parsed.seq;
+  }
+  if (event === "heartbeat") {
+    return JSON.parse(data).seq;
+  }
+  return null;
+};
+var createHeartbeatMonitor = (input) => {
+  let missedHeartbeats = 0;
+  let timer = null;
+  return {
+    recordHeartbeat: () => {
+      missedHeartbeats = 0;
+    },
+    start: () => {
+      timer = setInterval(() => {
+        missedHeartbeats += 1;
+        if (missedHeartbeats >= input.threshold) {
+          input.onConnectionLost?.();
+        }
+      }, input.intervalMs);
+    },
+    stop: () => {
+      if (timer)
+        clearInterval(timer);
+      timer = null;
+    }
+  };
+};
+var buildSyncStreamPath = (lastSeq) => lastSeq > 0 ? `/v1/sync/stream?since=${lastSeq}` : "/v1/sync/stream";
+var createSyncClient = (clientOptions) => ({
+  start: (input) => {
+    let lastSeq = 0;
+    let abortController = null;
+    let reconnectTimer = null;
+    let closed = false;
+    const state = { close: () => {}, connected: false };
+    const heartbeatMonitor = createHeartbeatMonitor({
+      intervalMs: input.heartbeatIntervalMs ?? DEFAULT_HEARTBEAT_INTERVAL_MS,
+      threshold: input.heartbeatThreshold ?? DEFAULT_HEARTBEAT_THRESHOLD,
+      onConnectionLost: input.onConnectionLost
+    });
+    const setConnected = () => {
+      const wasConnected = state.connected;
+      state.connected = true;
+      if (!wasConnected)
+        input.onConnected?.();
+    };
+    const setDisconnected = () => {
+      const wasConnected = state.connected;
+      state.connected = false;
+      if (wasConnected)
+        input.onDisconnected?.();
+    };
+    const handleEvent = (event, data) => {
+      heartbeatMonitor.recordHeartbeat();
+      const nextSeq = applySyncEvent(event, data, input);
+      if (nextSeq !== null)
+        lastSeq = Math.max(lastSeq, nextSeq);
+      if (event === "init")
+        setConnected();
+    };
+    const connect = async () => {
+      if (closed)
+        return;
+      abortController = new AbortController;
+      try {
+        const response = await resolveFetch(clientOptions)(resolveClientUrl(resolveBaseUrl(clientOptions), buildSyncStreamPath(lastSeq)), {
+          headers: Object.fromEntries(createRequestHeaders(clientOptions).entries()),
+          signal: abortController.signal
+        });
+        if (!response.ok || !response.body)
+          throw new Error("SSE connection failed");
+        await readSseStream(response.body, ({ event, data }) => handleEvent(event, data), {
+          signal: abortController.signal
+        });
+      } catch (err) {
+        if (closed || err.name === "AbortError")
+          return;
+      }
+      if (closed)
+        return;
+      setDisconnected();
+      reconnectTimer = setTimeout(connect, input.reconnectDelayMs ?? DEFAULT_RECONNECT_DELAY_MS);
+    };
+    heartbeatMonitor.start();
+    connect();
+    state.close = () => {
+      closed = true;
+      state.connected = false;
+      heartbeatMonitor.stop();
+      abortController?.abort();
+      if (reconnectTimer)
+        clearTimeout(reconnectTimer);
+    };
+    return state;
+  }
+});
+
 // src/client/tags.ts
 var createTagClient = (request) => ({
   list: (projectId) => request(`/v1/projects/${projectId}/ticket-tags`),
@@ -202,7 +453,7 @@ var createTemplateClient = (request) => ({
 });
 
 // src/client/tickets.ts
-var resolveBaseUrl = (options) => options.baseUrl ?? (typeof process !== "undefined" ? process.env.PSTDIO_API_URL : undefined) ?? "http://localhost:19840";
+var resolveBaseUrl2 = (options) => options.baseUrl ?? (typeof process !== "undefined" ? process.env.PSTDIO_API_URL : undefined) ?? "http://localhost:19840";
 var readErrorMessage2 = async (response) => {
   const errorBody = await response.json().catch(() => null);
   if (errorBody && typeof errorBody === "object" && errorBody !== null && "error" in errorBody) {
@@ -265,13 +516,13 @@ var createTicketClient = (request, options = {}) => ({
   },
   updateWhenAttemptStatus: (ticketId, input) => request(`/v1/tickets/${ticketId}/update-when-attempt-status`, { method: "POST", body: input }),
   listFiles: (ticketId) => request(`/v1/tickets/${ticketId}/files`),
-  getFileContent: async (ticketId, fileId) => {
-    const baseUrl = resolveBaseUrl(options);
+  getFileContent: async (ticketId, fileId, requestOptions = {}) => {
+    const baseUrl = resolveBaseUrl2(options);
     const fetchFn = options.fetch ?? globalThis.fetch;
     const headers = {};
     if (options.token)
       headers.authorization = `Bearer ${options.token}`;
-    const response = await fetchFn(`${baseUrl}/v1/tickets/${encodeURIComponent(ticketId)}/files/${encodeURIComponent(fileId)}/content`, { headers });
+    const response = await fetchFn(`${baseUrl}/v1/tickets/${encodeURIComponent(ticketId)}/files/${encodeURIComponent(fileId)}/content`, { cache: requestOptions.cache, headers, signal: requestOptions.signal });
     if (!response.ok) {
       throw new PstdioApiError(await readErrorMessage2(response), response.status);
     }
@@ -313,18 +564,21 @@ var createClient = (options = {}) => {
     projects: createProjectClient(request),
     tickets: createTicketClient(request, options),
     workspaces: createWorkspaceClient(request),
-    sessions: createSessionClient(request),
+    sessions: createSessionClient(request, options),
     statuses: createStatusClient(request),
     tags: createTagClient(request),
     templates: createTemplateClient(request),
     skills: createSkillClient(request),
     agents: createAgentClient(request),
-    actions: createActionClient(request),
-    extensions: createExtensionClient(request)
+    extensions: createExtensionClient(request),
+    settings: createSettingsClient(request),
+    sync: createSyncClient(options)
   };
 };
 export {
+  parseSyncDeleteEvent,
   createRequest,
   createClient,
+  applySyncEvent,
   PstdioApiError
 };

package/dist/client/projects.d.ts

@@ -1,25 +1,14 @@
 import type { CreateProjectInput, ListProjectActivityForTicketsInput, ListTicketActivityResponse, RegisterRepoInput, Repo } from "pstdio-api-contracts";
 import type { Project } from "../resources";
 import type { RequestFn } from "./request";
-type RegisteredPlugin = {
-    identity: string;
-    filePath: string;
-};
-type RegisteredPluginsResponse = {
-    plugins: RegisteredPlugin[];
-    pluginsDir: string | null;
-};
 export type ProjectClient = {
     list(): Promise<Project[]>;
     get(projectId: string): Promise<Project>;
     create(input: CreateProjectInput): Promise<Project>;
     delete(projectId: string): Promise<void>;
-    listPlugins(projectId: string): Promise<RegisteredPluginsResponse>;
-    registerPlugins(projectId: string): Promise<RegisteredPluginsResponse>;
     listActivity(projectId: string, input?: ListProjectActivityForTicketsInput): Promise<ListTicketActivityResponse>;
     listRepos(projectId: string): Promise<Repo[]>;
     registerRepo(projectId: string, input: RegisterRepoInput): Promise<Repo>;
     removeRepo(projectId: string, repoId: string): Promise<void>;
 };
 export declare const createProjectClient: (request: RequestFn) => ProjectClient;
-export {};

package/dist/client/request.d.ts

@@ -11,6 +11,15 @@ export type RequestOptions = {
     method?: string;
     body?: unknown;
     signal?: AbortSignal;
+    headers?: HeadersInit;
+    cache?: RequestCache;
 };
 export type RequestFn = <T>(path: string, options?: RequestOptions) => Promise<T>;
+export declare const resolveBaseUrl: (options: ClientOptions) => string;
+export declare const resolveClientUrl: (baseUrl: string, path: string) => string;
+export declare const resolveFetch: (options: ClientOptions) => typeof fetch;
+export declare const createRequestHeaders: (options: ClientOptions, reqOpts?: {
+    headers?: HeadersInit;
+    hasJsonBody?: boolean;
+}) => Headers;
 export declare const createRequest: (options: ClientOptions) => RequestFn;

package/dist/client/sessions.d.ts

@@ -1,8 +1,14 @@
 import type { ApprovalInput, CreateSessionInput, FollowUpInput, FollowUpResponse, ListSessionActivityInput, ListSessionActivityResponse, ResolveSessionIdInput, ResolveSessionIdResponse, SessionConversationResponse } from "pstdio-api-contracts";
 import type { Session } from "../resources";
-import type { RequestFn } from "./request";
+import { type ClientOptions, type RequestFn } from "./request";
+import { type SseEvent } from "./sse";
+export type ListSessionsInput = {
+    status?: string;
+    agent?: string;
+    archived?: boolean;
+};
 export type SessionClient = {
-    list(projectId: string): Promise<Session[]>;
+    list(projectId: string, input?: ListSessionsInput): Promise<Session[]>;
     get(sessionId: string): Promise<Session>;
     create(input: CreateSessionInput): Promise<Session>;
     archive(sessionId: string): Promise<void>;
@@ -12,5 +18,21 @@ export type SessionClient = {
     resolveSessionId(input: ResolveSessionIdInput): Promise<ResolveSessionIdResponse>;
     updateStatus(sessionId: string, status: string): Promise<Session>;
     listActivity(sessionId: string, input?: ListSessionActivityInput): Promise<ListSessionActivityResponse>;
+    stream(sessionId: string, onEvent: (event: SseEvent) => void, options?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+    connectStream(sessionId: string, handlers: SessionStreamHandlers, options?: {
+        attempt?: number;
+    }): SessionStreamConnection;
+};
+export type SessionStreamHandlers = {
+    onReady?: (data: unknown) => void;
+    onPatch?: (data: unknown) => void;
+    onApprovalRequest?: (data: unknown) => void;
+    onEnd?: (data: unknown) => void;
+    onError?: (error: unknown) => void;
+};
+export type SessionStreamConnection = {
+    close: () => void;
 };
-export declare const createSessionClient: (request: RequestFn) => SessionClient;
+export declare const createSessionClient: (request: RequestFn, clientOptions: ClientOptions) => SessionClient;

package/dist/client/settings.d.ts

@@ -0,0 +1,7 @@
+import type { Settings, UpdateSettingsInput } from "../api/settings";
+import type { RequestFn } from "./request";
+export type SettingsClient = {
+    get(): Promise<Settings>;
+    update(input: UpdateSettingsInput): Promise<Settings>;
+};
+export declare const createSettingsClient: (request: RequestFn) => SettingsClient;

package/dist/client/sse.d.ts

@@ -0,0 +1,15 @@
+export type SseEvent = {
+    event: string;
+    data: string;
+};
+export declare const parseSseEvent: (part: string) => {
+    event: string;
+    data: string;
+} | null;
+export declare const consumeSseBuffer: (buffer: string) => {
+    remainder: string;
+    events: SseEvent[];
+};
+export declare const readSseStream: (body: ReadableStream<Uint8Array>, onEvent: (event: SseEvent) => void, options?: {
+    signal?: AbortSignal;
+}) => Promise<void>;

package/dist/client/statuses.d.ts

@@ -1,6 +1,7 @@
 import type { AttemptStatus, CreateAttemptStatusInput, CreateStatusInput } from "pstdio-api-contracts";
 import type { Status } from "../resources";
 import type { RequestFn } from "./request";
+/** @deprecated Legacy core ticket status client. Ticket statuses are owned by the pstdio tickets extension. */
 export type StatusClient = {
     list(projectId: string): Promise<Status[]>;
     create(projectId: string, input: CreateStatusInput): Promise<Status>;
@@ -19,4 +20,5 @@ export type StatusClient = {
     }): Promise<AttemptStatus>;
     deleteAttemptStatus(projectId: string, statusId: string): Promise<void>;
 };
+/** @deprecated Legacy core ticket status client. Ticket statuses are owned by the pstdio tickets extension. */
 export declare const createStatusClient: (request: RequestFn) => StatusClient;

package/dist/client/sync.d.ts

@@ -0,0 +1,35 @@
+import { type ClientOptions } from "./request";
+export type SyncRow = {
+    id: string;
+    [key: string]: unknown;
+};
+export type SyncWriter = {
+    truncateAndWrite: (rows: SyncRow[]) => void;
+    upsert: (row: SyncRow) => void;
+    remove: (id: string) => void;
+};
+export type SyncWriterProvider = {
+    getWriter: (table: string) => SyncWriter | undefined;
+};
+export type SyncConnection = {
+    close: () => void;
+    connected: boolean;
+};
+export type StartSyncInput = SyncWriterProvider & {
+    onConnected?: () => void;
+    onDisconnected?: () => void;
+    onConnectionLost?: () => void;
+    heartbeatIntervalMs?: number;
+    heartbeatThreshold?: number;
+    reconnectDelayMs?: number;
+};
+export type SyncClient = {
+    start: (input: StartSyncInput) => SyncConnection;
+};
+export declare const parseSyncDeleteEvent: (data: string) => {
+    table: string;
+    id: string;
+    seq: number;
+};
+export declare const applySyncEvent: (event: string, data: string, writers: SyncWriterProvider) => number | null;
+export declare const createSyncClient: (clientOptions: ClientOptions) => SyncClient;

package/dist/client/tags.d.ts

@@ -1,6 +1,7 @@
 import type { CreateTagInput, CreateTagOptionInput, UpdateTagInput, UpdateTagOptionInput } from "../api/tags";
 import type { Tag, TagOption } from "../resources";
 import type { RequestFn } from "./request";
+/** @deprecated Legacy core ticket tag client. Ticket tags are owned by the pstdio tickets extension. */
 export type TagClient = {
     list(projectId: string): Promise<Tag[]>;
     create(projectId: string, input: CreateTagInput): Promise<Tag>;
@@ -10,4 +11,5 @@ export type TagClient = {
     updateOption(projectId: string, tagId: string, optionId: string, input: UpdateTagOptionInput): Promise<TagOption>;
     deleteOption(projectId: string, tagId: string, optionId: string): Promise<void>;
 };
+/** @deprecated Legacy core ticket tag client. Ticket tags are owned by the pstdio tickets extension. */
 export declare const createTagClient: (request: RequestFn) => TagClient;

package/dist/client/tickets.d.ts

@@ -1,6 +1,7 @@
 import type { CreateTicketAttemptInput, CreateTicketInput, ListProjectActivityForTicketsInput, ListTicketActivityInput, ListTicketActivityResponse, ListTicketsInput, TicketAttemptResponse, UpdateTicketInput, UpdateWhenAttemptStatusInput, UpdateWhenAttemptStatusResponse, UploadTicketFileInput } from "../api/tickets";
 import type { Ticket, TicketDetail, TicketFile, TicketListItem } from "../resources";
 import { type ClientOptions, type RequestFn } from "./request";
+/** @deprecated Legacy core ticket client. Ticket data is owned by the pstdio tickets extension. */
 export type TicketClient = {
     list(projectId: string, input?: ListTicketsInput): Promise<TicketListItem[]>;
     get(ticketId: string): Promise<TicketDetail>;
@@ -12,8 +13,12 @@ export type TicketClient = {
     listProjectActivity(projectId: string, input?: ListProjectActivityForTicketsInput): Promise<ListTicketActivityResponse>;
     updateWhenAttemptStatus(ticketId: string, input: UpdateWhenAttemptStatusInput): Promise<UpdateWhenAttemptStatusResponse>;
     listFiles(ticketId: string): Promise<TicketFile[]>;
-    getFileContent(ticketId: string, fileId: string): Promise<Uint8Array>;
+    getFileContent(ticketId: string, fileId: string, options?: {
+        cache?: RequestCache;
+        signal?: AbortSignal;
+    }): Promise<Uint8Array>;
     uploadFile(ticketId: string, input: UploadTicketFileInput): Promise<TicketFile>;
     deleteFile(ticketId: string, fileId: string): Promise<void>;
 };
+/** @deprecated Legacy core ticket client. Ticket data is owned by the pstdio tickets extension. */
 export declare const createTicketClient: (request: RequestFn, options?: ClientOptions) => TicketClient;

package/dist/client/workspaces.d.ts

@@ -4,7 +4,9 @@ import type { RequestFn } from "./request";
 export type WorkspaceClient = {
     list(projectId: string): Promise<WorkspaceListItem[]>;
     getByShorthand(projectId: string, shorthand: string): Promise<Workspace>;
+    /** @deprecated Requires legacy ticket-workspace linkage. Ticket ownership is moving to the pstdio tickets extension. */
     create(input: CreateWorkspaceInput): Promise<Workspace>;
+    /** @deprecated Legacy ticket attempt status mutation. Workspace status automation is extension-owned. */
     updateAttemptStatus(workspaceId: string, input: UpdateAttemptStatusInput): Promise<UpdateAttemptStatusResponse>;
     listActivity(workspaceId: string, input?: ListWorkspaceActivityInput): Promise<ListWorkspaceActivityResponse>;
     removeWorktree(workspaceId: string): Promise<RemoveWorktreeResponse>;

package/dist/extensions/define-command.d.ts

@@ -9,7 +9,7 @@ import type { ParamObjectSchema } from "./types/params";
  * @example
  *   export const sayHello = defineCommand({
  *     title: "Say hello",
- *     params: { name: params.text() },
+ *     params: { name: params.text({ required: true }) },
  *     async run(ctx) {
  *       ctx.params.name; // string
  *     },