@volter/supercode-frontend-vscode 0.1.11

package/vendor/supercode-frontend/client.mjs

@@ -0,0 +1,300 @@
+import { FRONTEND_METHODS, FRONTEND_SCHEMA } from './generated.mjs';
+import { GeneratedFrontendClient } from './generated-client.mjs';
+
+export { FRONTEND_EVENT_METHOD, FRONTEND_METHODS, FRONTEND_SCHEMA } from './generated.mjs';
+export { GeneratedFrontendClient } from './generated-client.mjs';
+
+class FrontendEmitter extends GeneratedFrontendClient {
+  #listeners = new Map();
+
+  on(event, listener) {
+    if (typeof listener !== 'function') throw new TypeError('listener must be a function');
+    const listeners = this.#listeners.get(event) ?? new Set();
+    listeners.add(listener);
+    this.#listeners.set(event, listeners);
+    return this;
+  }
+
+  off(event, listener) {
+    const listeners = this.#listeners.get(event);
+    listeners?.delete(listener);
+    if (listeners?.size === 0) this.#listeners.delete(event);
+    return this;
+  }
+
+  once(event, listener) {
+    const onceListener = (...args) => {
+      this.off(event, onceListener);
+      listener(...args);
+    };
+    return this.on(event, onceListener);
+  }
+
+  emit(event, ...args) {
+    for (const listener of [...(this.#listeners.get(event) ?? [])]) listener(...args);
+  }
+}
+
+export class FrontendClientError extends Error {
+  constructor(error) {
+    super(error?.message ?? 'frontend request failed');
+    this.name = error?.name ?? 'transport';
+    this.code = error?.code ?? null;
+    this.operation = error?.operation ?? null;
+    this.permission = error?.permission ?? null;
+    this.holder = error?.holder ?? null;
+    this.expiresAtMs = error?.expiresAtMs ?? null;
+    this.extensions = {
+      ...(error?.extensions && typeof error.extensions === 'object' ? error.extensions : {}),
+      ...Object.fromEntries(
+        Object.entries(error ?? {}).filter(([key]) => !['name', 'message', 'code', 'operation', 'permission', 'holder', 'expiresAtMs', 'extensions'].includes(key)),
+      ),
+    };
+  }
+}
+
+function requiredString(value, label) {
+  if (typeof value !== 'string' || value.length === 0) throw new TypeError(`${label} must be a non-empty string`);
+  return value;
+}
+
+function randomClientId() {
+  return `ts-${globalThis.crypto.randomUUID()}`;
+}
+
+function validateDescriptor(descriptor) {
+  if (!descriptor || descriptor.schema_version !== 2 || typeof descriptor.session_id !== 'string') {
+    throw new FrontendClientError({ name: 'transport', message: `peer is not ${FRONTEND_SCHEMA}` });
+  }
+  return descriptor;
+}
+
+export class FrontendClient extends FrontendEmitter {
+  #baseUrl;
+  #token;
+  #clientId;
+  #permissions;
+  #nextId = 1;
+  #fetch;
+  #eventAbort = null;
+  #pendingEventResponse = null;
+  #lastSequence = 0;
+
+  constructor({ baseUrl, token, clientId = randomClientId(), permissions = ['observe', 'interact', 'approve'], fetch = globalThis.fetch }) {
+    super();
+    this.#baseUrl = requiredString(baseUrl, 'baseUrl').replace(/\/$/, '');
+    this.#token = requiredString(token, 'token');
+    this.#clientId = requiredString(clientId, 'clientId');
+    this.#permissions = [...permissions];
+    if (typeof fetch !== 'function') throw new TypeError('fetch implementation is required');
+    // Browser-native `window.fetch` performs a receiver brand check. Calling
+    // it later as `this.#fetch(...)` would bind `this` to FrontendClient and
+    // throw `Illegal invocation`; bind only the native global while leaving
+    // injected test/host implementations receiver-neutral.
+    this.#fetch = fetch === globalThis.fetch ? fetch.bind(globalThis) : (...args) => fetch(...args);
+  }
+
+  get clientId() { return this.#clientId; }
+  get lastSequence() { return this.#lastSequence; }
+
+  headers() {
+    return {
+      authorization: `Bearer ${this.#token}`,
+      'content-type': 'application/json',
+      'x-supercode-client-id': this.#clientId,
+      'x-supercode-permissions': this.#permissions.join(','),
+    };
+  }
+
+  async rpc(method, params = {}, options = {}) {
+    const response = await this.#fetch(`${this.#baseUrl}/rpc`, {
+      method: 'POST',
+      headers: this.headers(),
+      body: JSON.stringify({ jsonrpc: '2.0', id: this.#nextId++, method, params }),
+      signal: options.signal,
+    });
+    if (!response.ok) throw new FrontendClientError({ name: 'transport', message: `frontend HTTP ${response.status}` });
+    const envelope = await response.json();
+    if (envelope.error) throw new FrontendClientError(envelope.error);
+    return envelope.result;
+  }
+
+  async describe(options) { return validateDescriptor(await this.rpc(FRONTEND_METHODS.describe, {}, options)); }
+  async attach(limit = 1000, { afterSequence = 0, ...options } = {}) {
+    // Establish the live subscription before taking the snapshot. The body
+    // stream buffers while the RPC is in flight, so every racing event is in
+    // either snapshot.replay or this already-open stream.
+    if (!this.#eventAbort) this.#pendingEventResponse = await this.#openEventStream(null, options.signal);
+    let snapshot;
+    try {
+      snapshot = await super.attach(limit, { afterSequence, ...options });
+    } catch (error) {
+      this.stopEvents();
+      throw error;
+    }
+    validateDescriptor(snapshot?.descriptor);
+    if (!Array.isArray(snapshot.history) || !Array.isArray(snapshot.replay) || !Number.isSafeInteger(snapshot.history_cursor)) {
+      throw new FrontendClientError({ name: 'transport', message: 'invalid frontend attachment snapshot' });
+    }
+    this.#lastSequence = Math.max(this.#lastSequence, afterSequence, snapshot.history_cursor);
+    snapshot.replay = snapshot.replay.filter((event) => event.sequence > this.#lastSequence);
+    for (const event of snapshot.replay) this.#lastSequence = Math.max(this.#lastSequence, event.sequence);
+    return snapshot;
+  }
+  async #openEventStream(afterSequence, signal) {
+    if (this.#eventAbort) throw new FrontendClientError({ name: 'transport', message: 'frontend event stream already active' });
+    const controller = new AbortController();
+    this.#eventAbort = controller;
+    if (signal) signal.addEventListener('abort', () => controller.abort(), { once: true });
+    try {
+      const suffix = afterSequence === null ? '' : `?after_sequence=${encodeURIComponent(afterSequence)}`;
+      const response = await this.#fetch(`${this.#baseUrl}/frontend/events${suffix}`, {
+        headers: this.headers(),
+        signal: controller.signal,
+      });
+      if (!response.ok || !response.body) throw new FrontendClientError({ name: 'transport', message: `frontend events HTTP ${response.status}` });
+      return response;
+    } catch (error) {
+      this.#eventAbort = null;
+      throw error;
+    }
+  }
+
+  async startEvents({ afterSequence = this.#lastSequence, signal } = {}) {
+    const response = this.#pendingEventResponse ?? await this.#openEventStream(afterSequence, signal);
+    this.#pendingEventResponse = null;
+    try {
+      const decoder = new TextDecoder();
+      let pending = '';
+      for await (const chunk of response.body) {
+        pending += decoder.decode(chunk, { stream: true });
+        let boundary;
+        while ((boundary = pending.indexOf('\n')) >= 0) {
+          const line = pending.slice(0, boundary).replace(/\r$/, '');
+          pending = pending.slice(boundary + 1);
+          if (!line.startsWith('data: ')) continue;
+          const event = JSON.parse(line.slice(6));
+          if (!Number.isSafeInteger(event.sequence) || event.sequence <= afterSequence || event.sequence <= this.#lastSequence) continue;
+          this.#lastSequence = event.sequence;
+          this.emit('event', event);
+        }
+      }
+    } finally {
+      this.#eventAbort = null;
+      this.#pendingEventResponse = null;
+      this.emit('disconnect');
+    }
+  }
+
+  stopEvents() {
+    this.#pendingEventResponse = null;
+    this.#eventAbort?.abort();
+  }
+  async detach(options) {
+    const result = await this.rpc(FRONTEND_METHODS.detach, {}, options);
+    this.stopEvents();
+    return result;
+  }
+  async close(options) {
+    const result = await this.rpc(FRONTEND_METHODS.close, {}, options);
+    this.stopEvents();
+    return result;
+  }
+}
+
+/** Header-capable WebSocket binding. The injected factory receives the exact
+ * authentication headers; browser-only factories must not move secrets into
+ * URLs and should use the HTTP/SSE client until an approved cookie/token
+ * bootstrap exists. */
+export class FrontendWebSocketClient extends FrontendEmitter {
+  #socket;
+  #nextId = 1;
+  #pending = new Map();
+  #lastSequence = 0;
+
+  constructor(socket) {
+    super();
+    if (!socket || typeof socket.send !== 'function' || typeof socket.addEventListener !== 'function') {
+      throw new TypeError('an open WebSocket-compatible transport is required');
+    }
+    this.#socket = socket;
+    socket.addEventListener('message', (message) => this.#receive(message.data));
+    socket.addEventListener('close', () => this.#disconnect('WebSocket transport closed'));
+    socket.addEventListener('error', () => this.#disconnect('WebSocket transport failed'));
+  }
+
+  static async connect({ url, token, clientId = randomClientId(), permissions = ['observe', 'interact', 'approve'], webSocketFactory }) {
+    requiredString(url, 'url');
+    requiredString(token, 'token');
+    if (typeof webSocketFactory !== 'function') throw new TypeError('header-capable webSocketFactory is required');
+    const socket = await webSocketFactory({
+      url,
+      headers: {
+        authorization: `Bearer ${token}`,
+        'x-supercode-client-id': requiredString(clientId, 'clientId'),
+        'x-supercode-permissions': [...permissions].join(','),
+      },
+    });
+    return new FrontendWebSocketClient(socket);
+  }
+
+  get lastSequence() { return this.#lastSequence; }
+
+  #receive(data) {
+    let envelope;
+    try {
+      envelope = JSON.parse(typeof data === 'string' ? data : new TextDecoder().decode(data));
+    } catch (error) {
+      this.emit('protocolError', error);
+      return;
+    }
+    if (envelope.method === 'frontend.v2.event') {
+      const event = envelope.params?.event;
+      if (event && Number.isSafeInteger(event.sequence) && event.sequence > this.#lastSequence) {
+        this.#lastSequence = event.sequence;
+        this.emit('event', event);
+      }
+      if (envelope.params?.error) this.emit('protocolError', new FrontendClientError(envelope.params.error));
+      return;
+    }
+    const pending = this.#pending.get(envelope.id);
+    if (!pending) return;
+    this.#pending.delete(envelope.id);
+    if (envelope.error) pending.reject(new FrontendClientError(envelope.error));
+    else pending.resolve(envelope.result);
+  }
+
+  #disconnect(message) {
+    for (const pending of this.#pending.values()) {
+      pending.reject(new FrontendClientError({name:'transport', message}));
+    }
+    this.#pending.clear();
+    this.emit('disconnect');
+  }
+
+  rpc(method, params = {}) {
+    const id = this.#nextId++;
+    return new Promise((resolve, reject) => {
+      this.#pending.set(id, {resolve, reject});
+      try {
+        this.#socket.send(JSON.stringify({jsonrpc:'2.0', id, method, params}));
+      } catch (error) {
+        this.#pending.delete(id);
+        reject(new FrontendClientError({name:'transport', message:String(error)}));
+      }
+    });
+  }
+
+  async describe() { return validateDescriptor(await this.rpc(FRONTEND_METHODS.describe)); }
+  async attach(limit = 1000, {afterSequence = 0} = {}) {
+    const snapshot = await this.rpc(FRONTEND_METHODS.attach, {limit, after_sequence:afterSequence});
+    validateDescriptor(snapshot?.descriptor);
+    this.#lastSequence = Math.max(this.#lastSequence, afterSequence, snapshot.history_cursor);
+    snapshot.replay = snapshot.replay.filter((event) => event.sequence > this.#lastSequence);
+    for (const event of snapshot.replay) this.#lastSequence = Math.max(this.#lastSequence, event.sequence);
+    return snapshot;
+  }
+  async detach() { const result = await this.rpc(FRONTEND_METHODS.detach); this.closeTransport(); return result; }
+  async close() { const result = await this.rpc(FRONTEND_METHODS.close); this.closeTransport(); return result; }
+  closeTransport() { this.#socket.close(); }
+}

package/vendor/supercode-frontend/contract.json

@@ -0,0 +1,289 @@
+{
+  "schema": "supercode.frontend.contract.v2",
+  "version": 2,
+  "canonical_sdk": "supercode.sdk.v1",
+  "description": "Language-neutral attachment facade over one SDK-owned runtime. Transport and client metadata are envelopes and never canonical session data.",
+  "opaque_extensions": {
+    "events": "FrontendEvent.payload",
+    "requests": "FrontendRequest.payload",
+    "compatibility": "FrontendRuntimeDescriptor.extensions",
+    "errors": "FrontendError.extensions",
+    "rule": "Unknown compatible fields are retained by clients and adapters but never written into canonical sessions, sidecars, reduction logs, or native exports."
+  },
+  "traced_needs": {
+    "source": "scripts/client-protocol-corpus/allowlist.json",
+    "families": [
+      "identity",
+      "history",
+      "cursor_replay",
+      "sequenced_events",
+      "capabilities",
+      "requests",
+      "semantic_actions",
+      "typed_errors",
+      "reconnect"
+    ],
+    "excluded_private_protocols": ["codex_app_server", "opencode_http", "goose_acp_extensions", "pi_rpc"]
+  },
+  "types": {
+    "JsonValue": {"kind": "json"},
+    "Empty": {"kind": "object", "fields": {}},
+    "ChatRole": {"kind": "enum", "values": ["system", "user", "assistant", "tool"]},
+    "FunctionCall": {
+      "kind": "object",
+      "fields": {
+        "name": {"type": "string"},
+        "arguments": {"type": "string"}
+      }
+    },
+    "ToolCall": {
+      "kind": "object",
+      "fields": {
+        "id": {"type": "string"},
+        "type": {"type": "string"},
+        "function": {"type": "FunctionCall"}
+      }
+    },
+    "ChatMessage": {
+      "kind": "object",
+      "fields": {
+        "role": {"type": "ChatRole"},
+        "content": {"type": {"kind": "union", "members": ["string", {"kind": "array", "items": "JsonValue"}]}, "optional": true},
+        "tool_calls": {"type": {"kind": "array", "items": "ToolCall"}, "optional": true},
+        "tool_call_id": {"type": "string", "optional": true},
+        "name": {"type": "string", "optional": true}
+      }
+    },
+    "FrontendActions": {
+      "kind": "object",
+      "fields": {
+        "submit": {"type": "boolean"},
+        "interrupt": {"type": "boolean"},
+        "steer": {"type": "boolean"},
+        "respond": {"type": "boolean"},
+        "detach": {"type": "boolean"},
+        "close": {"type": "boolean"}
+      }
+    },
+    "FrontendCommandDescriptor": {
+      "kind": "object",
+      "fields": {
+        "name": {"type": "string"},
+        "description": {"type": "string", "nullable": true},
+        "argument_hint": {"type": "string", "optional": true, "nullable": true}
+      }
+    },
+    "FrontendOperationKind": {"kind": "enum", "values": ["prompt", "file", "model", "session", "subagent", "image", "reduction"]},
+    "FrontendOperationDescriptor": {
+      "kind": "object",
+      "fields": {
+        "id": {"type": "string"},
+        "kind": {"type": "FrontendOperationKind"},
+        "command": {"type": "FrontendCommandDescriptor", "nullable": true}
+      }
+    },
+    "FrontendDisplayCapabilities": {
+      "kind": "object",
+      "fields": {
+        "event_kinds": {"type": {"kind": "array", "items": "string"}},
+        "opaque_fallback": {"type": "boolean"}
+      }
+    },
+    "FrontendTurnState": {"kind": "enum", "values": ["idle", "busy"]},
+    "FrontendConnectionState": {"kind": "enum", "values": ["connected", "shutting_down"]},
+    "FrontendRuntimeDescriptor": {
+      "kind": "object",
+      "extensible": true,
+      "fields": {
+        "schema_version": {"type": "u32", "const": 2},
+        "session_id": {"type": "string"},
+        "source_harness": {"type": "string", "nullable": true},
+        "emulation_profile": {"type": "string", "nullable": true},
+        "active_modules": {"type": {"kind": "array", "items": "string"}},
+        "commands": {"type": {"kind": "array", "items": "FrontendCommandDescriptor"}},
+        "operations": {"type": {"kind": "array", "items": "FrontendOperationDescriptor"}},
+        "actions": {"type": "FrontendActions"},
+        "display": {"type": "FrontendDisplayCapabilities"},
+        "model": {"type": "string"},
+        "turn_state": {"type": "FrontendTurnState"},
+        "connection_state": {"type": "FrontendConnectionState"},
+        "extensions": {"type": {"kind": "map", "values": "JsonValue"}, "optional": true}
+      }
+    },
+    "FrontendRequestKind": {"kind": "enum", "values": ["approval", "elicitation", "other"]},
+    "FrontendRequest": {
+      "kind": "object",
+      "extensible": true,
+      "fields": {
+        "id": {"type": "u64"},
+        "kind": {"type": "FrontendRequestKind"},
+        "payload": {"type": "JsonValue"}
+      }
+    },
+    "FrontendRequestEventPayload": {
+      "kind": "object",
+      "extensible": true,
+      "fields": {
+        "type": {"type": "string", "const": "request"},
+        "request": {"type": "FrontendRequest"}
+      }
+    },
+    "FrontendEventPayload": {"kind": "union", "members": ["FrontendRequestEventPayload", "JsonValue"]},
+    "FrontendEvent": {
+      "kind": "object",
+      "fields": {
+        "sequence": {"type": "u64"},
+        "kind": {"type": "string"},
+        "payload": {"type": "FrontendEventPayload"}
+      }
+    },
+    "FrontendAttachSnapshot": {
+      "kind": "object",
+      "fields": {
+        "descriptor": {"type": "FrontendRuntimeDescriptor"},
+        "history": {"type": {"kind": "array", "items": "ChatMessage"}},
+        "history_cursor": {"type": "u64"},
+        "replay": {"type": {"kind": "array", "items": "FrontendEvent"}}
+      }
+    },
+    "FrontendApprovalDecision": {"kind": "enum", "values": ["deny", "allow", "allow_for_session"]},
+    "FrontendElicitationAction": {"kind": "enum", "values": ["accept", "decline", "cancel"]},
+    "FrontendResponse": {
+      "kind": "tagged_union",
+      "tag": "kind",
+      "variants": {
+        "approval": {
+          "request_id": {"type": "u64"},
+          "decision": {"type": "FrontendApprovalDecision"}
+        },
+        "elicitation": {
+          "request_id": {"type": "u64"},
+          "action": {"type": "FrontendElicitationAction"},
+          "content": {"type": "JsonValue", "optional": true, "nullable": true}
+        },
+        "other": {
+          "request_id": {"type": "u64"},
+          "action": {"type": "FrontendElicitationAction"},
+          "content": {"type": "JsonValue", "optional": true, "nullable": true}
+        }
+      }
+    },
+    "FrontendOperationInvocation": {
+      "kind": "tagged_union",
+      "tag": "kind",
+      "variants": {
+        "prompt": {
+          "operation_id": {"type": "string"},
+          "arguments": {"type": "string"}
+        }
+      }
+    },
+    "FrontendOperationResult": {
+      "kind": "tagged_union",
+      "tag": "kind",
+      "variants": {
+        "prompt": {"reply": {"type": "string"}}
+      }
+    },
+    "RuntimeControllerLease": {
+      "kind": "object",
+      "fields": {
+        "client_id": {"type": "string"},
+        "expires_at_ms": {"type": "u64"}
+      }
+    },
+    "RuntimeObserverLease": {
+      "kind": "object",
+      "fields": {
+        "client_id": {"type": "string"},
+        "last_seen_ms": {"type": "u64"}
+      }
+    },
+    "RuntimeLeaseSnapshot": {
+      "kind": "object",
+      "fields": {
+        "controller": {"type": "RuntimeControllerLease", "nullable": true},
+        "observers": {"type": {"kind": "array", "items": "RuntimeObserverLease"}},
+        "lease_ttl_ms": {"type": "u64"}
+      }
+    },
+    "FrontendErrorName": {
+      "kind": "enum",
+      "values": ["unauthenticated", "unauthorized", "controller_required", "lease_expired", "invalid_argument", "not_found", "busy", "unsupported_action", "execution", "transport"]
+    },
+    "FrontendError": {
+      "kind": "object",
+      "extensible": true,
+      "fields": {
+        "name": {"type": "FrontendErrorName"},
+        "message": {"type": "string"},
+        "code": {"type": "i64", "optional": true},
+        "operation": {"type": "string", "optional": true},
+        "permission": {"type": "string", "optional": true},
+        "holder": {"type": "string", "optional": true, "nullable": true},
+        "expiresAtMs": {"type": "u64", "optional": true, "nullable": true},
+        "extensions": {"type": {"kind": "map", "values": "JsonValue"}, "optional": true}
+      }
+    },
+    "AttachParams": {
+      "kind": "object",
+      "fields": {
+        "limit": {"type": "u64"},
+        "after_sequence": {"type": "u64", "optional": true}
+      }
+    },
+    "PromptParams": {"kind": "object", "fields": {"prompt": {"type": "string"}}},
+    "MultimodalPromptParams": {
+      "kind": "object",
+      "fields": {
+        "prompt": {"type": "string"},
+        "image_urls": {"type": {"kind": "array", "items": "string"}, "optional": true}
+      }
+    },
+    "RespondParams": {"kind": "object", "fields": {"response": {"type": "FrontendResponse"}}},
+    "InvokeParams": {"kind": "object", "fields": {"operation": {"type": "FrontendOperationInvocation"}}},
+    "Accepted": {"kind": "object", "fields": {"accepted": {"type": "boolean"}}},
+    "Reply": {"kind": "object", "fields": {"reply": {"type": "string"}}},
+    "Interrupted": {"kind": "object", "fields": {"interrupted": {"type": "boolean"}}},
+    "Queued": {"kind": "object", "fields": {"queued": {"type": "boolean"}}},
+    "Closed": {"kind": "object", "fields": {"closed": {"type": "boolean"}}}
+  },
+  "methods": [
+    {"id": "describe", "wire": "frontend.v2.describe", "sdk_action": "resume", "params": "Empty", "result": "FrontendRuntimeDescriptor", "transports": ["local", "http", "websocket", "acp"]},
+    {"id": "attach", "wire": "frontend.v2.attach", "sdk_action": "events", "params": "AttachParams", "result": "FrontendAttachSnapshot", "transports": ["local", "http", "websocket", "acp"]},
+    {"id": "send_input", "wire": "frontend.v2.send_input", "sdk_action": "input", "params": "MultimodalPromptParams", "result": "Accepted", "transports": ["local", "http", "websocket", "acp"]},
+    {"id": "submit", "wire": "frontend.v2.submit", "sdk_action": "input", "params": "MultimodalPromptParams", "result": "Reply", "compatibility": "completion_waiting_alias", "transports": ["local", "http", "websocket", "acp"]},
+    {"id": "interrupt", "wire": "frontend.v2.interrupt", "sdk_action": "interrupt", "params": "Empty", "result": "Interrupted", "transports": ["local", "http", "websocket", "acp"]},
+    {"id": "steer", "wire": "frontend.v2.steer", "sdk_action": "steer", "params": "PromptParams", "result": "Queued", "transports": ["local", "http", "websocket", "acp"]},
+    {"id": "respond", "wire": "frontend.v2.respond", "sdk_action": "respond", "params": "RespondParams", "result": "Accepted", "transports": ["local", "http", "websocket", "acp"]},
+    {"id": "invoke", "wire": "frontend.v2.invoke", "sdk_action": "input", "params": "InvokeParams", "result": "FrontendOperationResult", "transports": ["local", "http", "websocket", "acp"]},
+    {"id": "lease", "wire": "frontend.v2.lease", "sdk_action": "events", "params": "Empty", "result": "RuntimeLeaseSnapshot", "transports": ["local", "http", "websocket", "acp"]},
+    {"id": "acquire_control", "wire": "frontend.v2.acquire_control", "sdk_action": "input", "params": "Empty", "result": "RuntimeLeaseSnapshot", "transports": ["local", "http", "websocket", "acp"]},
+    {"id": "take_control", "wire": "frontend.v2.take_control", "sdk_action": "input", "params": "Empty", "result": "RuntimeLeaseSnapshot", "transports": ["local", "http", "websocket", "acp"]},
+    {"id": "heartbeat", "wire": "frontend.v2.heartbeat", "sdk_action": "events", "params": "Empty", "result": "RuntimeLeaseSnapshot", "transports": ["local", "http", "websocket", "acp"]},
+    {"id": "detach", "wire": "frontend.v2.detach", "sdk_action": "events", "params": "Empty", "result": "RuntimeLeaseSnapshot", "transports": ["local", "http", "websocket", "acp"]},
+    {"id": "close", "wire": "frontend.v2.close", "sdk_action": "close", "params": "Empty", "result": "Closed", "transports": ["local", "http", "websocket", "acp"]}
+  ],
+  "events": {
+    "wire": "frontend.v2.event",
+    "type": "FrontendEvent",
+    "ordering": "strictly_increasing_sequence",
+    "reconnect": "attach.after_sequence"
+  },
+  "compatibility_aliases": {
+    "frontend.describe": "describe",
+    "frontend.attach": "attach",
+    "frontend.send_input": "send_input",
+    "frontend.invoke": "invoke",
+    "frontend.lease": "lease",
+    "frontend.acquire_control": "acquire_control",
+    "frontend.take_control": "take_control",
+    "frontend.heartbeat": "heartbeat",
+    "frontend.detach": "detach",
+    "frontend.close": "close",
+    "submit": "submit",
+    "interrupt": "interrupt",
+    "steer": "steer",
+    "respond": "respond"
+  }
+}

package/vendor/supercode-frontend/generated-client.d.mts

@@ -0,0 +1,18 @@
+// @generated by sdk/frontend/generate.mjs from contract.json. Do not edit.
+import type { Accepted, Closed, FrontendAttachSnapshot, FrontendOperationInvocation, FrontendOperationResult, FrontendResponse, FrontendRuntimeDescriptor, FrontendWireMethod, Interrupted, Queued, Reply, RuntimeLeaseSnapshot } from './generated.mjs';
+export abstract class GeneratedFrontendClient<Options = unknown> {
+  abstract rpc(method: FrontendWireMethod, params?: Record<string, unknown>, options?: Options): Promise<unknown>;
+  describe(options?: Options): Promise<FrontendRuntimeDescriptor>;
+  attach(limit?: number, options?: Options & {afterSequence?: number}): Promise<FrontendAttachSnapshot>;
+  sendInput(prompt: string, options?: Options & {imageUrls?: string[]}): Promise<Accepted>;
+  submit(prompt: string, options?: Options & {imageUrls?: string[]}): Promise<Reply>;
+  interrupt(options?: Options): Promise<Interrupted>;
+  steer(prompt: string, options?: Options): Promise<Queued>;
+  respond(response: FrontendResponse, options?: Options): Promise<Accepted>;
+  invoke(operation: FrontendOperationInvocation, options?: Options): Promise<FrontendOperationResult>;
+  lease(options?: Options): Promise<RuntimeLeaseSnapshot>;
+  takeControl(options?: Options): Promise<RuntimeLeaseSnapshot>;
+  heartbeat(options?: Options): Promise<RuntimeLeaseSnapshot>;
+  detach(options?: Options): Promise<RuntimeLeaseSnapshot>;
+  close(options?: Options): Promise<Closed>;
+}

package/vendor/supercode-frontend/generated-client.mjs

@@ -0,0 +1,20 @@
+// @generated by sdk/frontend/generate.mjs from contract.json. Do not edit.
+import { FRONTEND_METHODS } from './generated.mjs';
+
+export class GeneratedFrontendClient {
+  rpc() { throw new Error('GeneratedFrontendClient.rpc must be implemented by a transport'); }
+  describe(options) { return this.rpc(FRONTEND_METHODS.describe, {}, options); }
+  attach(limit = 1000, { afterSequence, ...options } = {}) { return this.rpc(FRONTEND_METHODS.attach, { limit, ...(afterSequence === undefined ? {} : {after_sequence:afterSequence}) }, options); }
+  sendInput(prompt, { imageUrls, ...options } = {}) { return this.rpc(FRONTEND_METHODS.send_input, { prompt, ...(imageUrls?.length ? {image_urls:imageUrls} : {}) }, options); }
+  submit(prompt, { imageUrls, ...options } = {}) { return this.rpc(FRONTEND_METHODS.submit, { prompt, ...(imageUrls?.length ? {image_urls:imageUrls} : {}) }, options); }
+  interrupt(options) { return this.rpc(FRONTEND_METHODS.interrupt, {}, options); }
+  steer(prompt, options) { return this.rpc(FRONTEND_METHODS.steer, { prompt }, options); }
+  respond(response, options) { return this.rpc(FRONTEND_METHODS.respond, { response }, options); }
+  invoke(operation, options) { return this.rpc(FRONTEND_METHODS.invoke, { operation }, options); }
+  lease(options) { return this.rpc(FRONTEND_METHODS.lease, {}, options); }
+  acquireControl(options) { return this.rpc(FRONTEND_METHODS.acquire_control, {}, options); }
+  takeControl(options) { return this.rpc(FRONTEND_METHODS.take_control, {}, options); }
+  heartbeat(options) { return this.rpc(FRONTEND_METHODS.heartbeat, {}, options); }
+  detach(options) { return this.rpc(FRONTEND_METHODS.detach, {}, options); }
+  close(options) { return this.rpc(FRONTEND_METHODS.close, {}, options); }
+}