@pstdio/sdk 0.25.0 → 0.35.0

package/README.md

@@ -63,3 +63,32 @@ The host delivers only events matching the view's project. Projectless events re
 Development and installed consumers both load built SDK entries. Repository development builds this package before starting the source CLI. Builds stage release files under `.publish` through the shared release script. Package verification installs those same staged artifacts into a temporary directory outside the monorepo and checks every entry point.
 
 Host authors should use the [workbench guide](https://github.com/pufflyai/prompt-studio/blob/main/packages/pstdio-workbench/README.md). Extension authors should use this SDK and public UI packages.
+
+## Workspace contract release bridge
+
+The alpha.10 host now provides workspace APIs alongside its existing repository APIs.
+Use `ctx.projectFiles` for the project's default workspace and `ctx.workspaceFiles`
+for the invocation's working files. Project file operations check the current workspace
+readiness and file capabilities. Remote workspaces never fall back to local files.
+
+`ctx.workspaces.getDefault()` returns the project workspace.
+`ctx.workspaces.listProviders()` returns available providers, their optional `icon`, and their parameters.
+Render these declared parameters after the user selects a workspace type. The Git
+provider supplies a **Base branch** selection; cloud providers supply their own fields.
+Local setup failures reject creation with the saved workspace ID and setup error.
+The workspace remains available for diagnosis and retry.
+Workspace context records expose `root_path` for a local directory and retain
+`worktree_path` during this release bridge.
+
+The SDK client exposes `client.workspaces.listProviders(projectId)` and
+`client.filesystem.createDirectory({ parent_path, name })`.
+Directory creation accepts one child name under an existing parent.
+
+Webviews can set `workspaceId` in `createWebviewClient(host, { workspaceId })`
+to run commands in that workspace. The host validates project ownership.
+
+Extensions that work with both host contracts can declare the exact versions
+`1.0.0-alpha.10 || 1.0.0-alpha.11` in `engines.pstdio`.
+General version ranges and wildcards remain unsupported.
+This declaration requires the bridge host; older alpha.10 hosts accept only one version.
+See [the staged release ADR](../../.pstdio/docs/adrs/0030-temporary-workspace-contract-release-bridge.md).

package/dist/api/index.js

@@ -6308,6 +6308,10 @@ var automationRunEventSchema = object({
   createdAt: string2()
 });
 var listAutomationRunEventsResponseSchema = object({ events: array(automationRunEventSchema) });
+// ../pstdio-api-contracts/src/extension-kernel/api-versions.ts
+var numericIdentifier = "(?:0|[1-9]\\d*)";
+var prereleaseIdentifier = `(?:${numericIdentifier}|\\d*[A-Za-z-][0-9A-Za-z-]*)`;
+var exactVersion = new RegExp(`^${numericIdentifier}\\.${numericIdentifier}\\.${numericIdentifier}(?:-${prereleaseIdentifier}(?:\\.${prereleaseIdentifier})*)?(?:\\+[0-9A-Za-z-]+(?:\\.[0-9A-Za-z-]+)*)?$`);
 // ../pstdio-api-contracts/src/extension-kernel/builtin-refs.ts
 var hostRef = (kind, id) => ({ extensionId: "pstdio", kind, id });
 var workbenchModes = {
@@ -6439,6 +6443,11 @@ var workspaceSlots = {
 var projectEvents = {
   opened: hostEventRef("project.opened")
 };
+var viewDataEvents = {
+  sessionsChanged: hostEventRef("view.sessions.changed"),
+  workspacesChanged: hostEventRef("view.workspaces.changed"),
+  repositoriesChanged: hostEventRef("view.repositories.changed")
+};
 var sessionEvents = {
   started: hostEventRef("session.started"),
   resumed: hostEventRef("session.resumed"),
@@ -6598,6 +6607,179 @@ var fileRecordSchema = object({
   created_at: string2(),
   updated_at: string2()
 });
+// ../pstdio-api-contracts/src/history-turn-evidence.ts
+var historyTurnEvidence = (known, native, prompt, body) => {
+  const signatures = (turn) => JSON.stringify([prompt(turn), body(turn)]);
+  if (known.length === native.length && known.every((turn, index) => signatures(turn) === signatures(native[index]))) {
+    return signatures;
+  }
+  const tokens = (turns) => {
+    const positions = new Map;
+    turns.forEach((turn, index) => {
+      for (const value of new Set(body(turn))) {
+        const token = JSON.stringify([prompt(turn), value]);
+        positions.set(token, positions.has(token) ? -1 : index);
+      }
+    });
+    return positions;
+  };
+  const left = tokens(known);
+  const right = tokens(native);
+  const matches = new Map;
+  const reverse = new Map;
+  for (const [token, index] of left) {
+    const other = right.get(token);
+    if (index < 0 || other === undefined || other < 0)
+      continue;
+    const targets = matches.get(index) ?? new Set;
+    targets.add(other);
+    matches.set(index, targets);
+    const sources = reverse.get(other) ?? new Set;
+    sources.add(index);
+    reverse.set(other, sources);
+  }
+  const keys = new Map;
+  known.forEach((turn, index) => {
+    keys.set(turn, `known:${index}`);
+  });
+  native.forEach((turn, index) => {
+    keys.set(turn, `native:${index}`);
+  });
+  for (const [index, targets] of matches) {
+    if (targets.size !== 1)
+      continue;
+    const other = [...targets][0];
+    if (reverse.get(other)?.size !== 1)
+      continue;
+    const key = `pair:${index}:${other}`;
+    keys.set(known[index], key);
+    keys.set(native[other], key);
+  }
+  return (turn) => keys.get(turn);
+};
+
+// ../pstdio-api-contracts/src/history-reconciliation.ts
+class HistoryConflict extends Error {
+}
+var submittedPrompt = (message) => message.parts.filter((part) => part.type === "text").map((part) => part.text).join(`
+`).replace(/\n\n<session-attachments>[\s\S]*<\/session-attachments>\s*$/, "").trim();
+var historyValueKey = (value) => JSON.stringify(value, (_key, item) => {
+  if (!item || typeof item !== "object" || Array.isArray(item))
+    return item;
+  return Object.fromEntries(Object.entries(item).sort(([a], [b]) => a.localeCompare(b)));
+});
+var historyMessageKey = (message) => historyValueKey([message.role, message.parts]);
+var positions = (items, key) => {
+  const result = new Map;
+  items.forEach((item, index) => {
+    const value = key(item);
+    const indices = result.get(value) ?? [];
+    indices.push(index);
+    result.set(value, indices);
+  });
+  return result;
+};
+var mergeOrderedHistory = (known, native, key, merge, refineKey) => {
+  if (!known.length)
+    return native;
+  if (!native.length)
+    return known;
+  const knownPositions = positions(known, key);
+  const nativePositions = positions(native, key);
+  const anchors = [];
+  for (const [value, indices] of knownPositions) {
+    const other = nativePositions.get(value);
+    if (indices.length === 1 && other?.length === 1)
+      anchors.push([indices[0], other[0]]);
+  }
+  if (!anchors.length) {
+    if (refineKey) {
+      const refined = mergeOrderedHistory(known, native, refineKey(known, native), merge);
+      return refined;
+    }
+    if (known.length === native.length && known.every((item, index) => key(item) === key(native[index]))) {
+      return known.map((item, index) => merge(item, native[index]));
+    }
+    throw new HistoryConflict("ambiguous_interval");
+  }
+  let left = 0;
+  let right = 0;
+  const result = [];
+  for (const [a, b] of anchors) {
+    if (b < right)
+      throw new HistoryConflict("conflicting_order");
+    result.push(...mergeOrderedHistory(known.slice(left, a), native.slice(right, b), key, merge, refineKey));
+    result.push(merge(known[a], native[b]));
+    left = a + 1;
+    right = b + 1;
+  }
+  result.push(...mergeOrderedHistory(known.slice(left), native.slice(right), key, merge, refineKey));
+  return result;
+};
+var splitHistoryTurns = (messages) => {
+  const turns = [];
+  for (const message of messages) {
+    if (message.role === "user" || !turns.length)
+      turns.push([]);
+    turns[turns.length - 1].push(message);
+  }
+  return turns;
+};
+var mergeHistoryMetadata = (known, native) => {
+  const files = native.parts.filter((part) => part.type === "file");
+  const fileKeys = new Set(files.map((part) => part.fileId ?? part.url));
+  const missing = known.parts.filter((part) => part.type === "file" && !fileKeys.has(part.fileId ?? part.url));
+  const parts = native.role === "user" ? [...known.parts.filter((part) => part.type === "text"), ...native.parts.filter((part) => part.type !== "text")] : native.parts;
+  return { ...known, ...native, parts: [...parts, ...missing] };
+};
+var isUsage = (message) => message.role === "system" && message.parts.length > 0 && message.parts.every((part) => part.type === "token_usage");
+var combineTextRuns = (messages) => {
+  const runs = [];
+  for (const message of messages) {
+    const previous = runs.at(-1);
+    const part = message.parts[0];
+    const previousPart = previous?.parts[0];
+    if (previous && message.role === previous.role && message.parts.length === 1 && previous.parts.length === 1 && (part.type === "text" || part.type === "reasoning") && previousPart?.type === part.type) {
+      runs[runs.length - 1] = { ...previous, parts: [{ ...part, text: previousPart.text + part.text }] };
+    } else
+      runs.push(message);
+  }
+  return runs;
+};
+var reconcileMessageHistory = (input, projection = {}) => {
+  const key = projection.key ?? historyMessageKey;
+  const merge = projection.merge ?? mergeHistoryMetadata;
+  const generated = projection.isGenerated ?? isUsage;
+  const mergeTurn = (known, native) => {
+    const startsWithUser = known[0]?.role === "user" && native[0]?.role === "user";
+    const body = (turn) => combineTextRuns(turn.slice(startsWithUser ? 1 : 0).filter((message) => !generated(message)));
+    const messages = mergeOrderedHistory(body(known), body(native), key, merge);
+    const metadata = [...native.filter(generated)];
+    const counts = new Map;
+    metadata.forEach((message) => {
+      counts.set(historyMessageKey(message), (counts.get(historyMessageKey(message)) ?? 0) + 1);
+    });
+    for (const message of known.filter(generated)) {
+      const value = historyMessageKey(message);
+      const remaining = counts.get(value) ?? 0;
+      if (remaining)
+        counts.set(value, remaining - 1);
+      else
+        metadata.push(message);
+    }
+    return [...startsWithUser ? [mergeHistoryMetadata(known[0], native[0])] : [], ...messages, ...metadata];
+  };
+  try {
+    const prompt = (turn) => turn[0]?.role === "user" ? `user:${submittedPrompt(turn[0])}` : "prefix";
+    const turns = mergeOrderedHistory(splitHistoryTurns(input.knownMessages), splitHistoryTurns(input.nativeMessages), prompt, mergeTurn, (known, native) => historyTurnEvidence(known, native, prompt, (turn) => combineTextRuns(turn.slice(1).filter((message) => !generated(message))).map(key)));
+    const messages = turns.flat().map((message, index) => message.index === undefined ? message : { ...message, index });
+    return { kind: "recovered", messages };
+  } catch (error) {
+    if (error instanceof HistoryConflict)
+      return { kind: "conflict", category: error.message };
+    throw error;
+  }
+};
 // ../pstdio-api-contracts/src/projects.ts
 var extensionSetupWarningSchema = object({
   code: literal("extension_setup_failed"),
@@ -6863,9 +7045,21 @@ var followUpDecisionSchema = union([
 var followUpResponseSchema = sessionSchema.extend({
   follow_up: followUpDecisionSchema
 });
+var sessionHistoryIssueSchema = object({
+  code: _enum(["reconciliation_conflict", "checkpoint_unreadable", "native_unavailable"]),
+  category: string2()
+});
+var sessionQueuedMessagesResponseSchema = object({ messages: array(sessionMessageSchema) });
+var sessionConversationSourcesSchema = object({
+  checkpoint: array(sessionMessageSchema).nullable(),
+  native: array(sessionMessageSchema).nullable(),
+  checkpointError: string2().nullable(),
+  nativeError: string2().nullable()
+});
 var sessionConversationResponseSchema = object({
+  historyIssue: sessionHistoryIssueSchema.optional(),
   session: sessionSchema,
-  messages: array(unknown())
+  messages: array(sessionMessageSchema)
 });
 var resolveSessionIdInputSchema = object({
   agent: string2(),
@@ -6959,6 +7153,9 @@ var workspaceProviderErrorSchema = object({
   retryable: boolean2(),
   occurred_at: string2()
 });
+var workspaceAnchorSchema = extensionResourceRefSchema.extend({
+  role: _enum(["primary", "context", "source", "result"]).optional()
+});
 var workspaceSchema = object({
   id: string2(),
   project_id: string2(),
@@ -6979,7 +7176,7 @@ var workspaceSchema = object({
   archived: boolean2(),
   workspace_shorthand: string2(),
   startup_log_file_id: string2().nullable(),
-  anchors_json: array(extensionResourceRefSchema),
+  anchors_json: array(workspaceAnchorSchema),
   created_at: string2(),
   updated_at: string2(),
   deleted_at: string2().nullable()
@@ -6989,7 +7186,9 @@ var createWorkspaceInputSchema = object({
   provider_id: string2().optional(),
   params: jsonObjectSchema.optional(),
   repo_id: string2().optional(),
-  base: string2().optional()
+  base: string2().optional(),
+  anchors: array(workspaceAnchorSchema).optional(),
+  shorthand_base: string2().trim().min(1).optional()
 });
 var renameWorkspaceInputSchema = object({
   name: string2().trim().min(1, "Workspace name is required").max(120, "Workspace name must be 120 characters or less")
@@ -7032,6 +7231,13 @@ var listWorkspaceFilesInputSchema = object({
   query: string2().optional(),
   limit: number2().int().positive().max(500).optional()
 });
+var workspaceProviderDescriptorSchema = object({
+  id: string2(),
+  label: localizableStringSchema,
+  icon: string2().optional(),
+  description: localizableStringSchema.optional(),
+  params: extensionParamObjectSchema
+});
 export {
   sessionAttachmentMimeTypesByExtension
 };