@gitterm/sdk 0.1.3 → 0.2.1

package/dist/direct/index.js

@@ -1,6 +1,1241 @@
 // src/direct/client.ts
 import { randomUUID } from "node:crypto";
+import { createOpencodeClient as createOpencodeClient2 } from "@opencode-ai/sdk";
+
+// ../agent-runtime/src/opencode.ts
 import { createOpencodeClient } from "@opencode-ai/sdk";
+
+// ../agent-runtime/src/types.ts
+function parseModelRef(model) {
+  if (!model)
+    return;
+  const separator = model.indexOf("/");
+  if (separator <= 0 || separator === model.length - 1) {
+    throw new Error('model must use the "provider/model" format');
+  }
+  return { providerID: model.slice(0, separator), modelID: model.slice(separator + 1) };
+}
+function permissionTitle(permission, patterns) {
+  return patterns.length > 0 ? `${permission}: ${patterns.join(", ")}` : permission;
+}
+function sessionStatusOf(status) {
+  return status === "busy" ? "busy" : status === "retry" ? "retry" : "idle";
+}
+function missingSessionSnapshot() {
+  return {
+    sessionExists: false,
+    busy: false,
+    retry: false,
+    messages: [],
+    finalText: null,
+    assistant: { exists: false, completed: false, error: null },
+    pendingInputs: []
+  };
+}
+var TOOL_OUTPUT_LIMIT = 4000;
+function truncateToolOutput(value) {
+  return value.length > TOOL_OUTPUT_LIMIT ? `${value.slice(0, TOOL_OUTPUT_LIMIT)}
+…[truncated ${value.length - TOOL_OUTPUT_LIMIT} chars]` : value;
+}
+
+// ../agent-runtime/src/opencode.ts
+function isOpencodeRunMessage(info, messageId) {
+  return info.id === messageId || info.role === "assistant" && info.parentID === messageId;
+}
+function snapshotParts(parts) {
+  const result = [];
+  for (const part of parts) {
+    if (part.type === "text") {
+      if (!part.ignored && part.text.trim())
+        result.push({ type: "text", text: part.text });
+    } else if (part.type === "tool") {
+      const state = part.state;
+      result.push({
+        type: "tool",
+        callId: part.callID,
+        tool: part.tool,
+        status: state.status,
+        title: "title" in state && state.title ? state.title : null,
+        input: state.input,
+        output: state.status === "completed" ? truncateToolOutput(state.output) : null,
+        error: state.status === "error" ? state.error : null,
+        startedAt: "time" in state ? new Date(state.time.start).toISOString() : null,
+        completedAt: (state.status === "completed" || state.status === "error") && state.time.end ? new Date(state.time.end).toISOString() : null
+      });
+    }
+  }
+  return result;
+}
+function findLastOpencodeRunAssistant(messages, messageId) {
+  return messages.findLast((message) => message.info.role === "assistant" && isOpencodeRunMessage(message.info, messageId));
+}
+function formatOpencodeError(error, model) {
+  if (!error)
+    return "OpenCode request failed";
+  if (typeof error === "string")
+    return error;
+  let message;
+  if (typeof error === "object" && "data" in error) {
+    const data = error.data;
+    if (typeof data?.message === "string")
+      message = data.message;
+    const name = "name" in error ? error.name : undefined;
+    const providerID = typeof data?.providerID === "string" ? data.providerID : model?.providerID;
+    const authenticationFailed = name === "ProviderAuthError" || (message ? /invalid api key|authentication|unauthorized/i.test(message) : false);
+    if (authenticationFailed && providerID) {
+      const selectedModel = model ? ` for model "${model.providerID}/${model.modelID}"` : "";
+      return `Model provider credential "${providerID}" was rejected${selectedModel}: ${message ?? "Authentication failed"}`;
+    }
+  }
+  return message ?? JSON.stringify(error) ?? "OpenCode request failed";
+}
+function createWorkspaceOpencodeClient(input) {
+  const authorization = input.password ? `Basic ${Buffer.from(`opencode:${input.password}`).toString("base64")}` : undefined;
+  return createOpencodeClient({
+    baseUrl: input.url,
+    directory: input.directory,
+    headers: { ...input.headers, ...authorization ? { Authorization: authorization } : {} },
+    fetch: input.fetch
+  });
+}
+
+// ../agent-runtime/src/http.ts
+class RuntimeHttpError extends Error {
+  status;
+  body;
+  tag;
+  constructor(status, body, tag) {
+    super(`OpenCode request failed with status ${status}${tag ? ` (${tag})` : ""}`);
+    this.status = status;
+    this.body = body;
+    this.tag = tag;
+  }
+}
+function isSessionNotFound(error) {
+  return error instanceof RuntimeHttpError && error.status === 404;
+}
+function authorizationHeader(password) {
+  return password ? { authorization: `Basic ${Buffer.from(`opencode:${password}`).toString("base64")}` } : {};
+}
+function runtimeUrl(target, path) {
+  const url = new URL(`${target.url.replace(/\/$/, "")}${path}`);
+  if (target.api === "v2" && target.directory && !url.searchParams.has("location")) {
+    url.searchParams.set("location", JSON.stringify({ directory: target.directory }));
+  }
+  return url.toString();
+}
+function createRuntimeHttp(target) {
+  const headers = { ...target.headers, ...authorizationHeader(target.password) };
+  async function send(path, init = {}) {
+    const { json, ...rest } = init;
+    const response = await (target.fetch ?? fetch)(runtimeUrl(target, path), {
+      ...rest,
+      headers: {
+        accept: "application/json",
+        ...json === undefined ? {} : { "content-type": "application/json" },
+        ...headers,
+        ...rest.headers
+      },
+      body: json === undefined ? rest.body : JSON.stringify(json),
+      signal: rest.signal ?? (target.signal ? AbortSignal.any([target.signal, AbortSignal.timeout(15000)]) : AbortSignal.timeout(15000))
+    });
+    if (!response.ok) {
+      const body = await response.text().catch(() => "");
+      let tag = null;
+      try {
+        const parsed = JSON.parse(body);
+        tag = typeof parsed._tag === "string" ? parsed._tag : typeof parsed.name === "string" ? parsed.name : null;
+      } catch {}
+      throw new RuntimeHttpError(response.status, body, tag);
+    }
+    return response;
+  }
+  return {
+    send,
+    async json(path, init) {
+      const response = await send(path, init);
+      const text = await response.text();
+      return text ? JSON.parse(text) : undefined;
+    }
+  };
+}
+async function* readServerSentEvents(url, init) {
+  const response = await (init.fetch ?? fetch)(url, {
+    headers: { accept: "text/event-stream", ...init.headers },
+    signal: init.signal
+  });
+  if (!response.ok || !response.body) {
+    await response.body?.cancel().catch(() => {
+      return;
+    });
+    throw new RuntimeHttpError(response.status, "", null);
+  }
+  const reader = response.body.getReader();
+  const onAbort = () => {
+    reader.cancel().catch(() => {});
+  };
+  init.signal.addEventListener("abort", onAbort, { once: true });
+  const decoder = new TextDecoder;
+  let buffer = "";
+  let data = [];
+  let event = null;
+  try {
+    init.signal.throwIfAborted();
+    yield { event: "open", data: "" };
+    while (true) {
+      const { value, done } = await reader.read();
+      if (done)
+        break;
+      buffer += decoder.decode(value, { stream: true });
+      let newline = buffer.indexOf(`
+`);
+      while (newline >= 0) {
+        let line = buffer.slice(0, newline);
+        buffer = buffer.slice(newline + 1);
+        newline = buffer.indexOf(`
+`);
+        if (line.endsWith("\r"))
+          line = line.slice(0, -1);
+        if (line === "") {
+          if (data.length > 0)
+            yield { event, data: data.join(`
+`) };
+          data = [];
+          event = null;
+          continue;
+        }
+        if (line.startsWith(":"))
+          continue;
+        const colon = line.indexOf(":");
+        const field = colon === -1 ? line : line.slice(0, colon);
+        let fieldValue = colon === -1 ? "" : line.slice(colon + 1);
+        if (fieldValue.startsWith(" "))
+          fieldValue = fieldValue.slice(1);
+        if (field === "data")
+          data.push(fieldValue);
+        else if (field === "event")
+          event = fieldValue;
+      }
+    }
+    init.signal.throwIfAborted();
+  } finally {
+    init.signal.removeEventListener("abort", onAbort);
+    await reader.cancel().catch(() => {
+      return;
+    });
+  }
+}
+async function* signalStream(target, path, parse, signal) {
+  const stream = readServerSentEvents(runtimeUrl(target, path), {
+    headers: { ...target.headers, ...authorizationHeader(target.password) },
+    signal,
+    fetch: target.fetch
+  });
+  for await (const item of stream) {
+    if (item.event === "open") {
+      yield { type: "connected" };
+      continue;
+    }
+    const raw = parseEventData(item.data);
+    const parsed = raw && parse(raw);
+    if (parsed)
+      yield parsed;
+  }
+}
+function parseEventData(data) {
+  try {
+    const parsed = JSON.parse(data);
+    return parsed && typeof parsed === "object" ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function asRecord(value) {
+  return value && typeof value === "object" ? value : {};
+}
+function asString(value) {
+  return typeof value === "string" ? value : null;
+}
+function asStringArray(value) {
+  return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+
+// ../agent-runtime/src/v1.ts
+function createV1Runtime(target) {
+  const client = () => createWorkspaceOpencodeClient(target);
+  const http = createRuntimeHttp(target);
+  const directoryQuery = `?directory=${encodeURIComponent(target.directory)}`;
+  return {
+    api: "v1",
+    async createSession(input) {
+      const created = await client().session.create({
+        body: input.title ? { title: input.title } : undefined,
+        query: { directory: target.directory }
+      });
+      if (created.error || !created.data)
+        throw new Error(formatOpencodeError(created.error));
+      return { id: created.data.id, title: created.data.title };
+    },
+    async prompt(input) {
+      const model = parseModelRef(input.model);
+      const prompted = await client().session.promptAsync({
+        path: { id: input.sessionId },
+        query: { directory: target.directory },
+        body: {
+          messageID: input.messageId,
+          parts: [{ type: "text", text: input.prompt }],
+          agent: input.agent,
+          model
+        }
+      });
+      if (prompted.error)
+        throw new Error(formatOpencodeError(prompted.error));
+    },
+    async abort(sessionId) {
+      const result = await client().session.abort({
+        path: { id: sessionId },
+        query: { directory: target.directory }
+      });
+      if (result.error)
+        throw new Error(formatOpencodeError(result.error));
+    },
+    async deleteSession(sessionId) {
+      const result = await client().session.delete({
+        path: { id: sessionId },
+        query: { directory: target.directory }
+      });
+      if (result.error)
+        throw new Error(formatOpencodeError(result.error));
+    },
+    async snapshot(sessionId, messageId) {
+      const api = client();
+      const [session, statuses, messages, permissions, questions] = await Promise.all([
+        api.session.get({
+          path: { id: sessionId },
+          query: { directory: target.directory },
+          signal: target.signal
+        }),
+        api.session.status({ query: { directory: target.directory }, signal: target.signal }),
+        api.session.messages({
+          path: { id: sessionId },
+          query: { directory: target.directory },
+          signal: target.signal
+        }),
+        http.json(`/permission${directoryQuery}`),
+        http.json(`/question${directoryQuery}`)
+      ]);
+      if (session.response.status === 404)
+        return missingSessionSnapshot();
+      if (session.error || !session.data)
+        throw new Error(formatOpencodeError(session.error));
+      if (statuses.error || !statuses.data)
+        throw new Error(formatOpencodeError(statuses.error));
+      if (messages.error || !messages.data)
+        throw new Error(formatOpencodeError(messages.error));
+      const status = statuses.data[sessionId];
+      const userIndex = messages.data.findIndex((message) => message.info.id === messageId);
+      const superseded = userIndex >= 0 && messages.data.slice(userIndex + 1).some((message) => message.info.role === "user");
+      const assistant = findLastOpencodeRunAssistant(messages.data, messageId);
+      const assistantInfo = assistant?.info.role === "assistant" ? assistant.info : undefined;
+      const assistantModel = assistantInfo ? { providerID: assistantInfo.providerID, modelID: assistantInfo.modelID } : undefined;
+      const finalText = assistant ? textOf(assistant.parts) : "";
+      const pendingInputs = [
+        ...(Array.isArray(permissions) ? permissions : []).map(asRecord).filter((permission) => permission.sessionID === sessionId).map(permissionRequest),
+        ...(Array.isArray(questions) ? questions : []).map(asRecord).filter((question) => question.sessionID === sessionId).map(questionRequest)
+      ];
+      return {
+        sessionExists: true,
+        superseded,
+        busy: status?.type === "busy",
+        retry: status?.type === "retry",
+        messages: messages.data.filter((message) => isOpencodeRunMessage(message.info, messageId)).map((message) => ({
+          id: message.info.id,
+          role: message.info.role,
+          createdAt: new Date(message.info.time.created).toISOString(),
+          completedAt: message.info.role === "assistant" && message.info.time.completed ? new Date(message.info.time.completed).toISOString() : null,
+          text: textOf(message.parts),
+          parts: snapshotParts(message.parts),
+          error: message.info.role === "assistant" && message.info.error ? formatOpencodeError(message.info.error, {
+            providerID: message.info.providerID,
+            modelID: message.info.modelID
+          }) : null
+        })),
+        finalText: finalText || null,
+        assistant: {
+          exists: Boolean(assistant),
+          completed: assistantInfo?.time.completed != null,
+          error: assistantInfo?.error ? {
+            kind: assistantInfo.error.name === "MessageAbortedError" ? "aborted" : "error",
+            message: formatOpencodeError(assistantInfo.error, assistantModel)
+          } : null
+        },
+        pendingInputs: superseded ? [] : pendingInputs
+      };
+    },
+    subscribe: (signal) => signalStream(target, `/event${directoryQuery}`, parseV1Signal, signal),
+    async replyPermission(sessionId, requestId, reply) {
+      const result = await client().postSessionIdPermissionsPermissionId({
+        path: { id: sessionId, permissionID: requestId },
+        query: { directory: target.directory },
+        body: { response: reply }
+      });
+      if (result.response.status === 404)
+        throw new RuntimeHttpError(404, "", null);
+      if (result.error)
+        throw new Error(formatOpencodeError(result.error));
+    },
+    async replyQuestion(_sessionId, request, answers) {
+      await http.send(`/question/${encodeURIComponent(request.id)}/reply${directoryQuery}`, {
+        method: "POST",
+        json: { answers }
+      });
+    },
+    async rejectQuestion(_sessionId, requestId) {
+      await http.send(`/question/${encodeURIComponent(requestId)}/reject${directoryQuery}`, {
+        method: "POST",
+        json: {}
+      });
+    }
+  };
+}
+function textOf(parts) {
+  return parts.filter((part) => part.type === "text" && !part.ignored).map((part) => part.text ?? "").join(`
+`).trim();
+}
+function permissionRequest(raw) {
+  const tool = asRecord(raw.tool);
+  const permission = asString(raw.permission) ?? asString(raw.type) ?? "permission";
+  const patterns = asStringArray(raw.patterns).length > 0 ? asStringArray(raw.patterns) : asStringArray(Array.isArray(raw.pattern) ? raw.pattern : [raw.pattern]);
+  const createdMs = asRecord(raw.time).created;
+  return {
+    id: asString(raw.id) ?? "",
+    kind: "permission",
+    createdAt: typeof createdMs === "number" ? new Date(createdMs).toISOString() : null,
+    toolCallId: asString(tool.callID) ?? asString(raw.callID),
+    permission,
+    patterns,
+    always: asStringArray(raw.always),
+    title: asString(raw.title) ?? permissionTitle(permission, patterns)
+  };
+}
+function questionRequest(raw) {
+  const tool = asRecord(raw.tool);
+  const questions = Array.isArray(raw.questions) ? raw.questions.map(asRecord) : [];
+  return {
+    id: asString(raw.id) ?? "",
+    kind: "question",
+    createdAt: null,
+    toolCallId: asString(tool.callID),
+    questions: questions.map((question, index) => ({
+      key: `q${index}`,
+      header: asString(question.header) ?? `Question ${index + 1}`,
+      question: asString(question.question) ?? "",
+      options: (Array.isArray(question.options) ? question.options.map(asRecord) : []).map((option) => ({
+        label: asString(option.label) ?? "",
+        description: asString(option.description) ?? ""
+      })),
+      multiple: question.multiple === true,
+      custom: question.custom !== false
+    }))
+  };
+}
+function changed(sessionId) {
+  return sessionId ? { type: "session.changed", sessionId } : null;
+}
+function parseV1Signal(raw) {
+  const properties = asRecord(raw.properties);
+  switch (raw.type) {
+    case "message.updated":
+    case "message.removed":
+      return changed(asString(asRecord(properties.info).sessionID) ?? asString(properties.sessionID));
+    case "message.part.updated":
+    case "message.part.removed":
+      return changed(asString(asRecord(properties.part).sessionID) ?? asString(properties.sessionID));
+    case "session.status": {
+      const sessionId = asString(properties.sessionID);
+      const status = sessionStatusOf(asString(asRecord(properties.status).type));
+      return sessionId ? { type: "session.status", sessionId, status } : null;
+    }
+    case "session.idle": {
+      const sessionId = asString(properties.sessionID);
+      return sessionId ? { type: "session.status", sessionId, status: "idle" } : null;
+    }
+    case "session.error": {
+      const sessionId = asString(properties.sessionID);
+      return sessionId ? { type: "session.error", sessionId, message: formatOpencodeError(properties.error) } : null;
+    }
+    case "session.deleted": {
+      const sessionId = asString(asRecord(properties.info).id);
+      return sessionId ? { type: "session.deleted", sessionId } : null;
+    }
+    case "permission.asked":
+    case "permission.updated": {
+      const sessionId = asString(properties.sessionID);
+      return sessionId ? { type: "input.asked", sessionId, request: permissionRequest(properties) } : null;
+    }
+    case "question.asked": {
+      const sessionId = asString(properties.sessionID);
+      return sessionId ? { type: "input.asked", sessionId, request: questionRequest(properties) } : null;
+    }
+    case "permission.replied":
+    case "question.replied":
+    case "question.rejected": {
+      const sessionId = asString(properties.sessionID);
+      const requestId = asString(properties.requestID) ?? asString(properties.permissionID);
+      return sessionId && requestId ? { type: "input.resolved", sessionId, requestId } : null;
+    }
+    default:
+      return null;
+  }
+}
+
+// ../agent-runtime/src/v2.ts
+function session(sessionId) {
+  return `/api/session/${encodeURIComponent(sessionId)}`;
+}
+function createV2Runtime(target) {
+  const http = createRuntimeHttp(target);
+  async function switchSessionOptions(sessionId, agent, model) {
+    const modelRef = parseModelRef(model);
+    if (modelRef) {
+      await http.send(`${session(sessionId)}/model`, {
+        method: "POST",
+        json: { model: { providerID: modelRef.providerID, id: modelRef.modelID } }
+      });
+    }
+    if (agent) {
+      await http.send(`${session(sessionId)}/agent`, { method: "POST", json: { agent } });
+    }
+  }
+  return {
+    api: "v2",
+    async createSession(input) {
+      const modelRef = parseModelRef(input.model);
+      const created = await http.json("/api/session", {
+        method: "POST",
+        json: {
+          title: input.title,
+          agent: input.agent,
+          model: modelRef ? { providerID: modelRef.providerID, id: modelRef.modelID } : undefined,
+          location: { directory: target.directory }
+        }
+      });
+      return { id: created.data.id, title: created.data.title ?? input.title ?? "Agent run" };
+    },
+    async prompt(input) {
+      await switchSessionOptions(input.sessionId, input.agent, input.model);
+      await http.send(`${session(input.sessionId)}/prompt`, {
+        method: "POST",
+        json: { id: input.messageId, text: input.prompt }
+      });
+    },
+    async abort(sessionId) {
+      await http.send(`${session(sessionId)}/interrupt`, { method: "POST", json: {} });
+    },
+    async deleteSession(sessionId) {
+      await http.send(session(sessionId), { method: "DELETE" });
+    },
+    async snapshot(sessionId, messageId) {
+      try {
+        await http.send(session(sessionId));
+      } catch (error) {
+        if (isSessionNotFound(error))
+          return missingSessionSnapshot();
+        throw error;
+      }
+      const [active, messages, permissions, forms] = await Promise.all([
+        http.json("/api/session/active"),
+        listMessages(sessionId),
+        http.json(`${session(sessionId)}/permission`),
+        http.json(`${session(sessionId)}/form`)
+      ]);
+      const runMessages = selectRunMessages(messages, messageId);
+      const userIndex = messages.findIndex((message) => message.id === messageId);
+      const superseded = userIndex >= 0 && messages.slice(userIndex + 1).some((message) => message.type === "user");
+      const assistant = runMessages.findLast((message) => message.type === "assistant");
+      const assistantTime = asRecord(assistant?.time);
+      const assistantError = asRecord(assistant?.error);
+      const finalText = assistant ? assistantText(assistant) : "";
+      return {
+        sessionExists: true,
+        superseded,
+        busy: sessionId in asRecord(active.data),
+        retry: Boolean(assistant?.retry) && assistantTime.completed == null,
+        messages: runMessages.map(normalizeMessage),
+        finalText: finalText || null,
+        assistant: {
+          exists: Boolean(assistant),
+          completed: assistantTime.completed != null,
+          error: assistant?.error ? {
+            kind: assistantError.type === "aborted" ? "aborted" : "error",
+            message: asString(assistantError.message) ?? "Agent request failed"
+          } : null
+        },
+        pendingInputs: superseded ? [] : [
+          ...(permissions.data ?? []).map(asRecord).map(permissionRequest2),
+          ...(forms.data ?? []).map(asRecord).map(formRequest)
+        ]
+      };
+    },
+    subscribe: (signal) => signalStream(target, "/api/event", parseV2Signal, signal),
+    async replyPermission(sessionId, requestId, reply) {
+      await http.send(`${session(sessionId)}/permission/${encodeURIComponent(requestId)}/reply`, {
+        method: "POST",
+        json: { reply }
+      });
+    },
+    async replyQuestion(sessionId, request, answers) {
+      const answer = {};
+      request.questions.forEach((question, index) => {
+        const selected = (answers[index] ?? []).map((label) => optionValue(question, label));
+        answer[question.key] = question.multiple ? selected : selected[0] ?? "";
+      });
+      await http.send(`${session(sessionId)}/form/${encodeURIComponent(request.id)}/reply`, {
+        method: "POST",
+        json: { answer }
+      });
+    },
+    async rejectQuestion(sessionId, requestId) {
+      await http.send(`${session(sessionId)}/form/${encodeURIComponent(requestId)}/cancel`, {
+        method: "POST",
+        json: {}
+      });
+    }
+  };
+  async function listMessages(sessionId) {
+    const pageSize = 200;
+    const messages = [];
+    let query = `?order=asc&limit=${pageSize}`;
+    while (true) {
+      const page = await http.json(`${session(sessionId)}/message${query}`);
+      const items = page.data ?? [];
+      messages.push(...items.map(asRecord));
+      const next = page.cursor?.next ?? null;
+      if (!next || items.length < pageSize)
+        break;
+      query = `?cursor=${encodeURIComponent(next)}&limit=${pageSize}`;
+    }
+    return messages;
+  }
+}
+function selectRunMessages(messages, messageId) {
+  const start = messages.findIndex((message) => message.id === messageId);
+  if (start === -1)
+    return [];
+  const selected = [messages[start]];
+  for (const message of messages.slice(start + 1)) {
+    if (message.type === "user")
+      break;
+    if (message.type === "assistant")
+      selected.push(message);
+  }
+  return selected;
+}
+function assistantText(message) {
+  return (Array.isArray(message.content) ? message.content.map(asRecord) : []).filter((item) => item.type === "text").map((item) => asString(item.text) ?? "").join(`
+`).trim();
+}
+function toIso(value) {
+  return typeof value === "number" ? new Date(value).toISOString() : null;
+}
+function normalizeMessage(message) {
+  const time = asRecord(message.time);
+  const id = asString(message.id) ?? "";
+  if (message.type === "user") {
+    const text = asString(message.text) ?? "";
+    return {
+      id,
+      role: "user",
+      createdAt: toIso(time.created) ?? new Date().toISOString(),
+      completedAt: null,
+      text,
+      parts: text ? [{ type: "text", text }] : [],
+      error: null
+    };
+  }
+  const parts = [];
+  for (const item of Array.isArray(message.content) ? message.content.map(asRecord) : []) {
+    if (item.type === "text") {
+      const text = asString(item.text) ?? "";
+      if (text.trim())
+        parts.push({ type: "text", text });
+    } else if (item.type === "tool") {
+      const state = asRecord(item.state);
+      const toolTime = asRecord(item.time);
+      const status = asString(state.status);
+      const output = (Array.isArray(state.content) ? state.content.map(asRecord) : []).filter((content) => content.type === "text").map((content) => asString(content.text) ?? "").join(`
+`);
+      parts.push({
+        type: "tool",
+        callId: asString(item.id) ?? "",
+        tool: asString(item.name) ?? "tool",
+        status: status === "running" || status === "completed" || status === "error" ? status : "pending",
+        title: asString(asRecord(state.metadata).title),
+        input: typeof state.input === "object" && state.input ? asRecord(state.input) : {},
+        output: status === "completed" ? truncateToolOutput(output) : null,
+        error: status === "error" ? asString(asRecord(state.error).message) ?? "Tool failed" : null,
+        startedAt: toIso(toolTime.ran) ?? toIso(toolTime.created),
+        completedAt: toIso(toolTime.completed)
+      });
+    }
+  }
+  const error = asRecord(message.error);
+  return {
+    id,
+    role: "assistant",
+    createdAt: toIso(time.created) ?? new Date().toISOString(),
+    completedAt: toIso(time.completed),
+    text: assistantText(message),
+    parts,
+    error: message.error ? asString(error.message) ?? "Agent request failed" : null
+  };
+}
+function permissionRequest2(raw) {
+  const action = asString(raw.action) ?? "permission";
+  const patterns = asStringArray(raw.resources);
+  return {
+    id: asString(raw.id) ?? "",
+    kind: "permission",
+    createdAt: toIso(asRecord(raw.time).created),
+    toolCallId: asString(asRecord(raw.source).id),
+    permission: action,
+    patterns,
+    always: asStringArray(raw.save),
+    title: permissionTitle(action, patterns)
+  };
+}
+function formRequest(raw) {
+  const fields = Array.isArray(raw.fields) ? raw.fields.map(asRecord) : [];
+  const tool = asRecord(asRecord(raw.metadata).tool);
+  return {
+    id: asString(raw.id) ?? "",
+    kind: "question",
+    createdAt: toIso(asRecord(raw.time).created),
+    toolCallId: asString(tool.id) ?? asString(tool.callID),
+    questions: fields.map((field, index) => {
+      const key = asString(field.key) ?? `q${index}`;
+      return {
+        key,
+        header: asString(field.title) ?? key,
+        question: asString(field.description) ?? asString(field.title) ?? key,
+        options: (Array.isArray(field.options) ? field.options.map(asRecord) : []).map((option) => {
+          const value = asString(option.value);
+          const label = asString(option.label) ?? value ?? "";
+          return {
+            label,
+            description: asString(option.description) ?? "",
+            ...value && value !== label ? { value } : {}
+          };
+        }),
+        multiple: field.type === "multiselect",
+        custom: field.custom !== false
+      };
+    })
+  };
+}
+function optionValue(question, label) {
+  const option = question.options.find((candidate) => candidate.label === label);
+  return option?.value ?? label;
+}
+function parseV2Signal(raw) {
+  const data = asRecord(raw.data);
+  const type = asString(raw.type) ?? "";
+  const sessionId = asString(data.sessionID);
+  const changed2 = () => sessionId ? { type: "session.changed", sessionId } : null;
+  if (type.startsWith("session.step.") || type.startsWith("session.tool."))
+    return changed2();
+  switch (type) {
+    case "session.text.ended":
+    case "session.reasoning.ended":
+    case "session.message.content.updated":
+    case "session.inbox.delivered":
+      return changed2();
+    case "session.execution.started":
+      return sessionId ? { type: "session.status", sessionId, status: "busy" } : null;
+    case "session.execution.succeeded":
+    case "session.execution.failed":
+    case "session.execution.interrupted":
+    case "session.idle":
+      return sessionId ? { type: "session.status", sessionId, status: "idle" } : null;
+    case "session.retry.scheduled":
+      return sessionId ? { type: "session.status", sessionId, status: "retry" } : null;
+    case "session.status": {
+      const status = sessionStatusOf(asString(asRecord(data.status).type));
+      return sessionId ? { type: "session.status", sessionId, status } : null;
+    }
+    case "session.error":
+      return sessionId ? {
+        type: "session.error",
+        sessionId,
+        message: asString(asRecord(data.error).message) ?? "Agent request failed"
+      } : null;
+    case "session.deleted": {
+      const deleted = sessionId ?? asString(data.id) ?? asString(asRecord(data.info).id);
+      return deleted ? { type: "session.deleted", sessionId: deleted } : null;
+    }
+    case "permission.asked":
+      return sessionId ? { type: "input.asked", sessionId, request: permissionRequest2(data) } : null;
+    case "form.created": {
+      const form = asRecord(data.form);
+      const formSession = asString(form.sessionID);
+      return formSession ? { type: "input.asked", sessionId: formSession, request: formRequest(form) } : null;
+    }
+    case "permission.replied": {
+      const requestId = asString(data.requestID);
+      return sessionId && requestId ? { type: "input.resolved", sessionId, requestId } : null;
+    }
+    case "form.replied":
+    case "form.cancelled": {
+      const requestId = asString(data.id);
+      return sessionId && requestId ? { type: "input.resolved", sessionId, requestId } : null;
+    }
+    default:
+      return null;
+  }
+}
+// ../agent-runtime/src/derive.ts
+var MISSING_ASSISTANT_GRACE_MS = 1e4;
+function deriveRunState(snapshot, context) {
+  if (!snapshot.sessionExists) {
+    return { status: "cancelled", errorMessage: "Session was deleted before the run completed" };
+  }
+  const assistantError = snapshot.assistant.error;
+  if (assistantError?.kind === "aborted") {
+    return { status: "cancelled", errorMessage: assistantError.message };
+  }
+  if (assistantError)
+    return { status: "failed", errorMessage: assistantError.message };
+  if (!snapshot.superseded) {
+    if (snapshot.pendingInputs.length > 0)
+      return { status: "awaiting_input", errorMessage: null };
+    if (snapshot.retry)
+      return { status: "retrying", errorMessage: null };
+    if (snapshot.busy)
+      return { status: "running", errorMessage: null };
+  }
+  if (!snapshot.assistant.exists) {
+    if (context.sessionError)
+      return { status: "failed", errorMessage: context.sessionError };
+    const now = context.now ?? Date.now();
+    const waited = context.submittedAt ? now - context.submittedAt.getTime() : 0;
+    if (context.submittedAt && waited >= MISSING_ASSISTANT_GRACE_MS) {
+      return {
+        status: "failed",
+        errorMessage: "OpenCode stopped before producing an assistant response"
+      };
+    }
+    return { status: "running", errorMessage: null };
+  }
+  if (!snapshot.assistant.completed)
+    return { status: "running", errorMessage: null };
+  return { status: "completed", errorMessage: null };
+}
+// ../agent-runtime/src/index.ts
+function getRuntime(target) {
+  return target.api === "v2" ? createV2Runtime(target) : createV1Runtime(target);
+}
+
+// ../agent-runtime/src/replies.ts
+function questionAnswers(request, answers) {
+  const keys = request.questions.map((question) => question.key);
+  if (Object.keys(answers).some((key) => !keys.includes(key)) || keys.some((key) => !Object.hasOwn(answers, key))) {
+    throw new Error(`Answers must cover exactly the question keys ${JSON.stringify(keys)}`);
+  }
+  return request.questions.map((question) => {
+    if (!question.options.length && !question.custom) {
+      throw new Error(`Question "${question.key}" has no options and does not accept custom answers`);
+    }
+    const selected = answers[question.key];
+    if (!Array.isArray(selected) || !selected.length || !question.multiple && selected.length !== 1) {
+      throw new Error(`Question "${question.key}" requires ${question.multiple ? "at least one answer" : "one answer"}`);
+    }
+    if (selected.some((answer) => typeof answer !== "string" || !answer.trim() || !question.custom && !question.options.some((option) => option.label === answer))) {
+      throw new Error(`Invalid answer for question "${question.key}"`);
+    }
+    if (new Set(selected).size !== selected.length)
+      throw new Error(`Duplicate answer for question "${question.key}"`);
+    return selected;
+  });
+}
+
+// src/errors.ts
+var WORKSPACE_LIFECYCLE_ERROR_CODES = [
+  "WORKSPACE_NOT_RUNNING",
+  "WORKSPACE_TERMINATED",
+  "WORKSPACE_NON_RECOVERABLE",
+  "WORKSPACE_START_TIMEOUT",
+  "WORKSPACE_RESTART_FAILED"
+];
+
+class GittermError extends Error {
+  code;
+  cause;
+  constructor(code, message, options = {}) {
+    super(message);
+    this.name = "GittermError";
+    this.code = code;
+    this.cause = options.cause;
+  }
+}
+
+class WorkspaceLifecycleError extends GittermError {
+  constructor(code, message, options = {}) {
+    super(code, message, options);
+    this.name = "WorkspaceLifecycleError";
+  }
+}
+
+class AgentRunError extends GittermError {
+  run;
+  constructor(run, code) {
+    super(code, run.error ?? (code === "INPUT_REQUIRED" ? "The agent needs input; supply a handler or use runs.respond()" : `Agent run ${run.status}`));
+    this.run = run;
+    this.name = "AgentRunError";
+  }
+}
+
+// src/runs.ts
+function terminal(status) {
+  return status === "completed" || status === "failed" || status === "cancelled";
+}
+function aborted(signal) {
+  if (signal?.aborted)
+    throw new GittermError("ABORTED", "Run observation was aborted; the agent was not cancelled");
+}
+async function abortable(operation, signal) {
+  if (signal.aborted)
+    operation.catch(() => {});
+  aborted(signal);
+  let onAbort;
+  try {
+    return await Promise.race([
+      operation,
+      new Promise((_, reject) => {
+        onAbort = () => reject(new GittermError("ABORTED", "Run observation was aborted; the agent was not cancelled"));
+        signal.addEventListener("abort", onAbort, { once: true });
+      })
+    ]);
+  } finally {
+    if (onAbort)
+      signal.removeEventListener("abort", onAbort);
+  }
+}
+function delay(ms, signal) {
+  aborted(signal);
+  return new Promise((resolve, reject) => {
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(new GittermError("ABORTED", "Operation aborted"));
+    };
+    const timer = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+async function deadline(options, operation) {
+  aborted(options?.signal);
+  const timeoutMs = options?.timeoutMs ?? 30 * 60000;
+  if (!Number.isFinite(timeoutMs) || timeoutMs < 0)
+    throw new GittermError("BAD_REQUEST", "timeoutMs must be finite and non-negative");
+  const controller = new AbortController;
+  const onAbort = () => controller.abort();
+  options?.signal?.addEventListener("abort", onAbort, { once: true });
+  let timedOut = false;
+  const timer = setTimeout(() => {
+    timedOut = true;
+    controller.abort();
+  }, timeoutMs);
+  try {
+    return await operation(controller.signal);
+  } catch (error) {
+    if (timedOut)
+      throw new GittermError("TIMEOUT", "Run observation timed out; the agent was not cancelled", {
+        cause: error
+      });
+    aborted(options?.signal);
+    throw error;
+  } finally {
+    clearTimeout(timer);
+    options?.signal?.removeEventListener("abort", onAbort);
+    controller.abort();
+  }
+}
+async function* runEvents(states) {
+  const seen = new Set;
+  let pending = new Set;
+  let status;
+  for await (const run of states) {
+    if (run.status !== status) {
+      status = run.status;
+      yield { type: "run.status", run };
+    }
+    const current = new Set(run.pendingInputs.map((request) => request.id));
+    for (const requestId of pending) {
+      if (!current.has(requestId))
+        yield { type: "input.resolved", run, requestId };
+    }
+    pending = current;
+    for (const request of run.pendingInputs) {
+      if (seen.has(request.id))
+        continue;
+      seen.add(request.id);
+      yield { type: "input.required", run, request };
+    }
+    if (run.status === "completed" || run.status === "failed" || run.status === "cancelled") {
+      yield { type: `run.${run.status}`, run };
+      return;
+    }
+  }
+}
+function runHelpers(operations) {
+  return {
+    events: (ref, options) => runEvents(operations.watch(ref, options)),
+    wait: (ref, options) => deadline(options, async (signal) => {
+      for await (const run of operations.watch(ref, { signal })) {
+        if (terminal(run.status) || run.status === "awaiting_input" && options?.until !== "terminal")
+          return run;
+      }
+      throw new GittermError("NETWORK", "Run stream ended before a terminal state");
+    }),
+    result: (ref, options) => deadline(options, async (signal) => {
+      for await (const event of runEvents(operations.watch(ref, { signal }))) {
+        aborted(signal);
+        if (event.type === "run.completed")
+          return event.run;
+        if (event.type === "run.failed")
+          throw new AgentRunError(event.run, "RUN_FAILED");
+        if (event.type === "run.cancelled")
+          throw new AgentRunError(event.run, "RUN_CANCELLED");
+        if (event.type !== "input.required")
+          continue;
+        const { request } = event;
+        let reply;
+        if (request.kind === "permission") {
+          if (!options?.onPermission)
+            throw new AgentRunError(event.run, "INPUT_REQUIRED");
+          reply = {
+            type: "permission",
+            response: await abortable(Promise.resolve(options.onPermission(request, { signal })), signal)
+          };
+        } else {
+          if (!options?.onQuestion)
+            throw new AgentRunError(event.run, "INPUT_REQUIRED");
+          reply = {
+            type: "question",
+            ...await abortable(Promise.resolve(options.onQuestion(request, { signal })), signal)
+          };
+        }
+        aborted(signal);
+        try {
+          await abortable(operations.respond(ref, { requestId: request.id, reply }), signal);
+        } catch (error) {
+          if (!(error instanceof GittermError) || error.code !== "INPUT_NOT_PENDING")
+            throw error;
+        }
+      }
+      throw new GittermError("NETWORK", "Run stream ended before a terminal state");
+    })
+  };
+}
+
+// src/direct/runs.ts
+function directRuntime(workspace, fetchImpl, signal) {
+  return getRuntime({
+    url: workspace.runtime.url,
+    directory: workspace.runtime.directory,
+    password: workspace.runtime.password ?? null,
+    headers: workspace.runtime.headers,
+    api: workspace.opencodeApi,
+    fetch: fetchImpl,
+    signal
+  });
+}
+function directError(error) {
+  if (error instanceof GittermError)
+    return error;
+  if (error instanceof RuntimeHttpError) {
+    return new GittermError(error.status === 404 ? "NOT_FOUND" : error.status === 401 ? "UNAUTHORIZED" : error.status === 403 ? "FORBIDDEN" : error.status >= 500 ? "SERVER_ERROR" : "BAD_REQUEST", error.message, { cause: error });
+  }
+  return new GittermError("NETWORK", error instanceof Error ? error.message : "OpenCode request failed", { cause: error });
+}
+function directRunOperations(assertWorkspace, fetchImpl) {
+  function assertRun(run) {
+    assertWorkspace(run.workspace);
+    if (run.workspaceId !== run.workspace.id)
+      throw new GittermError("BAD_REQUEST", "Run belongs to another workspace");
+  }
+  async function get(run, sessionError, signal) {
+    assertRun(run);
+    if (terminal(run.status))
+      return run;
+    try {
+      const snapshot = await directRuntime(run.workspace, fetchImpl, signal).snapshot(run.sessionId, run.messageId);
+      const derived = deriveRunState(snapshot, {
+        submittedAt: run.submittedAt ? new Date(run.submittedAt) : null,
+        sessionError
+      });
+      return {
+        ...run,
+        status: derived.status,
+        error: derived.errorMessage,
+        finalText: snapshot.finalText,
+        pendingInputs: terminal(derived.status) ? [] : snapshot.pendingInputs,
+        completedAt: terminal(derived.status) ? new Date().toISOString() : null
+      };
+    } catch (error) {
+      throw directError(error);
+    }
+  }
+  async function respond(run, input) {
+    const current = await get(run);
+    const request = current.pendingInputs.find((candidate) => candidate.id === input.requestId);
+    if (current.status !== "awaiting_input" || !request)
+      throw new GittermError("INPUT_NOT_PENDING", "Input request is no longer pending");
+    const runtime = directRuntime(run.workspace, fetchImpl);
+    if (request.kind !== input.reply.type)
+      throw new GittermError("BAD_REQUEST", "Reply type does not match the input request");
+    if (input.reply.type === "question" && ("answers" in input.reply ? "reject" in input.reply : input.reply.reject !== true)) {
+      throw new GittermError("BAD_REQUEST", "Question replies require answers or an explicit rejection, not both");
+    }
+    let answers;
+    if (request.kind === "question" && input.reply.type === "question" && "answers" in input.reply) {
+      try {
+        answers = questionAnswers(request, input.reply.answers);
+      } catch (error) {
+        throw new GittermError("BAD_REQUEST", error instanceof Error ? error.message : "Invalid answers");
+      }
+    }
+    try {
+      if (request.kind === "permission" && input.reply.type === "permission") {
+        if (!["once", "always", "reject"].includes(input.reply.response))
+          throw new GittermError("BAD_REQUEST", "Invalid permission response");
+        await runtime.replyPermission(run.sessionId, request.id, input.reply.response);
+      } else if (request.kind === "question") {
+        if (answers)
+          await runtime.replyQuestion(run.sessionId, request, answers);
+        else
+          await runtime.rejectQuestion(run.sessionId, request.id);
+      }
+    } catch (error) {
+      if (error instanceof RuntimeHttpError && error.status === 404)
+        throw new GittermError("INPUT_NOT_PENDING", "Input request was resolved by another responder");
+      throw directError(error);
+    }
+    return get(current);
+  }
+  async function* watch(run, options) {
+    assertRun(run);
+    aborted(options?.signal);
+    if (terminal(run.status)) {
+      yield run;
+      return;
+    }
+    const controller = new AbortController;
+    const onAbort = () => controller.abort();
+    options?.signal?.addEventListener("abort", onAbort, { once: true });
+    const runtime = directRuntime(run.workspace, fetchImpl);
+    let dirty = false;
+    let wake;
+    let sessionError = null;
+    let streamError;
+    const notify = () => {
+      dirty = true;
+      wake?.();
+      wake = undefined;
+    };
+    const probe = setInterval(notify, 60000);
+    const pump = (async () => {
+      let backoff = 1000;
+      while (!controller.signal.aborted) {
+        try {
+          for await (const event of runtime.subscribe(controller.signal)) {
+            if (event.type === "connected") {
+              backoff = 1000;
+              notify();
+            } else if (event.sessionId === run.sessionId) {
+              if (event.type === "session.error")
+                sessionError = event.message;
+              notify();
+            }
+          }
+        } catch (error) {
+          if (controller.signal.aborted)
+            return;
+          if (error instanceof RuntimeHttpError && [400, 401, 403, 404].includes(error.status)) {
+            streamError = error;
+            notify();
+            return;
+          }
+        }
+        await delay(backoff, controller.signal).catch(() => {});
+        backoff = Math.min(backoff * 2, 30000);
+      }
+    })();
+    let current = run;
+    let previous;
+    try {
+      while (true) {
+        aborted(options?.signal);
+        if (!dirty)
+          await abortable(new Promise((resolve) => {
+            wake = resolve;
+          }), controller.signal);
+        dirty = false;
+        if (streamError)
+          throw directError(streamError);
+        current = await abortable(get(current, sessionError, controller.signal), controller.signal);
+        const key = JSON.stringify([current.status, current.pendingInputs]);
+        if (key !== previous) {
+          previous = key;
+          yield current;
+        }
+        if (terminal(current.status))
+          return;
+      }
+    } finally {
+      clearInterval(probe);
+      options?.signal?.removeEventListener("abort", onAbort);
+      controller.abort();
+      await pump;
+    }
+  }
+  return {
+    get: (run) => get(run),
+    watch,
+    respond,
+    ...runHelpers({ watch, respond }),
+    async messages(run) {
+      assertRun(run);
+      try {
+        return (await directRuntime(run.workspace, fetchImpl).snapshot(run.sessionId, run.messageId)).messages;
+      } catch (error) {
+        throw directError(error);
+      }
+    },
+    async cancel(run) {
+      const current = await get(run);
+      if (terminal(current.status))
+        return { cancelled: current.status === "cancelled" };
+      const runtime = directRuntime(run.workspace, fetchImpl);
+      try {
+        for (const request of current.pendingInputs) {
+          if (request.kind === "permission")
+            await runtime.replyPermission(run.sessionId, request.id, "reject");
+          else
+            await runtime.rejectQuestion(run.sessionId, request.id);
+        }
+        await runtime.abort(run.sessionId);
+        return { cancelled: true };
+      } catch (error) {
+        throw directError(error);
+      }
+    }
+  };
+}
+
+// src/direct/client.ts
 import {
   createOpencodeClient as createOpencodeV2Client
 } from "@opencode-ai/sdk/v2";
@@ -22,9 +1257,9 @@ function resolveDirectImage(image) {
   return image?.trim() || DIRECT_OPENCODE_SERVER_IMAGE;
 }
 function directModelAuth(credential) {
-  if (credential.type === "oauth") {
-    if (!credential.refreshToken.trim())
-      throw new Error("OAuth refreshToken is required");
+  if (credential.source === "oauth") {
+    if (typeof credential.refreshToken !== "string" || !credential.refreshToken.trim())
+      throw new GittermError("MODEL_CREDENTIAL_INVALID", "OAuth refreshToken is required");
     if (credential.expiresAt != null && (!Number.isFinite(credential.expiresAt) || credential.expiresAt < 0)) {
       throw new Error("OAuth expiresAt must be a non-negative Unix epoch time in milliseconds");
     }
@@ -37,8 +1272,9 @@ function directModelAuth(credential) {
       ...credential.enterpriseUrl ? { enterpriseUrl: credential.enterpriseUrl } : {}
     };
   }
-  if (!credential.apiKey.trim())
-    throw new Error("Model credential apiKey is required");
+  if (credential.source !== "apiKey" || typeof credential.apiKey !== "string" || !credential.apiKey.trim()) {
+    throw new GittermError("MODEL_CREDENTIAL_INVALID", "Inline model credential apiKey is required");
+  }
   return {
     type: "api",
     key: credential.apiKey,
@@ -99,8 +1335,15 @@ function buildDirectProvisioningPlan(input) {
     }
   }
   const credentials = new Map;
-  for (const credential of input.modelCredentials ?? []) {
-    const providerName = credential.providerName.trim();
+  if (input.models?.default && !/^[^/]+\/.+$/.test(input.models.default)) {
+    throw new GittermError("BAD_REQUEST", "Model must use provider/model format");
+  }
+  if (input.models?.inherit && input.models.inherit !== "none") {
+    throw new GittermError("MODEL_CREDENTIAL_INVALID", "Direct mode cannot inherit dashboard credentials");
+  }
+  for (const [key, source] of Object.entries(input.models?.providers ?? {})) {
+    const credential = { ...source, providerName: key };
+    const providerName = key.trim();
     if (!providerName)
       throw new Error("Model credential providerName is required");
     if (credentials.has(providerName)) {
@@ -117,6 +1360,7 @@ function buildDirectProvisioningPlan(input) {
   const config = {
     $schema: "https://opencode.ai/config.json",
     ...input.opencode?.config,
+    ...input.models?.default ? { model: input.models.default } : {},
     username: "Gitterm direct",
     permission: {
       external_directory: "allow",
@@ -257,8 +1501,8 @@ function basicAuthHeader(password) {
   return `Basic ${Buffer.from(`opencode:${password}`).toString("base64")}`;
 }
 async function waitForDirectRuntime(runtime, timeoutMs = 60000) {
-  const deadline = Date.now() + timeoutMs;
-  while (Date.now() < deadline) {
+  const deadline2 = Date.now() + timeoutMs;
+  while (Date.now() < deadline2) {
     const controller = new AbortController;
     const timer = setTimeout(() => controller.abort(), 5000);
     const ready = await fetch(runtime.url, {
@@ -810,8 +2054,8 @@ function createExeDevDirectProvider(config) {
     return token;
   }
   async function waitUntilRunning(vmName) {
-    const deadline = Date.now() + 60000;
-    while (Date.now() < deadline) {
+    const deadline2 = Date.now() + 60000;
+    while (Date.now() < deadline2) {
       const status = await execute(`ls ${vmName}`).then(resultStatus).catch(() => "pending");
       if (status === "running")
         return;
@@ -885,9 +2129,9 @@ function createExeDevDirectProvider(config) {
         await startRuntime(handle);
         await execute(`share port ${vmName} ${handle.serve.port}`);
         await execute(`share set-private ${vmName}`);
-        const directRuntime = await runtime(handle, input.password);
-        await waitForDirectRuntime(directRuntime);
-        return { externalId: serializeHandle2(handle), runtime: directRuntime };
+        const directRuntime2 = await runtime(handle, input.password);
+        await waitForDirectRuntime(directRuntime2);
+        return { externalId: serializeHandle2(handle), runtime: directRuntime2 };
       } catch (error) {
         if (handle.owned) {
           await execute(`rm ${vmName}`).catch(() => {
@@ -922,9 +2166,9 @@ function createExeDevDirectProvider(config) {
       await execute(`share set-private ${handle.vmName}`);
       if (!workspace.runtime.password)
         throw new Error("exe.dev runtime password is missing");
-      const directRuntime = await runtime(handle, workspace.runtime.password);
-      await waitForDirectRuntime(directRuntime);
-      return directRuntime;
+      const directRuntime2 = await runtime(handle, workspace.runtime.password);
+      await waitForDirectRuntime(directRuntime2);
+      return directRuntime2;
     },
     async terminate(workspace) {
       const handle = parseHandle3(workspace.externalId);
@@ -1100,8 +2344,8 @@ function createRailwayDirectProvider(config) {
   };
   const latestDeployment = async (serviceId) => (await serviceSnapshot(serviceId)).serviceInstance?.latestDeployment ?? undefined;
   const waitForDeployment = async (serviceId, previousDeploymentId) => {
-    const deadline = Date.now() + DEPLOYMENT_TIMEOUT_MS;
-    while (Date.now() < deadline) {
+    const deadline2 = Date.now() + DEPLOYMENT_TIMEOUT_MS;
+    while (Date.now() < deadline2) {
       const deployment = await latestDeployment(serviceId);
       if (deployment && deployment.id !== previousDeploymentId) {
         if (deployment.status === "SUCCESS")
@@ -1115,8 +2359,8 @@ function createRailwayDirectProvider(config) {
     throw new Error("Timed out waiting for Railway deployment");
   };
   const waitForDeploymentRemoval = async (serviceId, deploymentId) => {
-    const deadline = Date.now() + DEPLOYMENT_TIMEOUT_MS;
-    while (Date.now() < deadline) {
+    const deadline2 = Date.now() + DEPLOYMENT_TIMEOUT_MS;
+    while (Date.now() < deadline2) {
       const deployment = await latestDeployment(serviceId);
       if (!deployment || deployment.id !== deploymentId || deployment.status === "REMOVED")
         return;
@@ -1505,9 +2749,10 @@ function resolveProvider(provider) {
       return createVercelDirectProvider(provider);
   }
 }
-function runtimeClient(workspace) {
+function runtimeClient(workspace, fetchImpl) {
   const authorization = workspace.runtime.password ? `Basic ${Buffer.from(`opencode:${workspace.runtime.password}`).toString("base64")}` : undefined;
-  return createOpencodeClient({
+  return createOpencodeClient2({
+    fetch: fetchImpl,
     baseUrl: workspace.runtime.url,
     directory: workspace.runtime.directory,
     headers: {
@@ -1516,9 +2761,12 @@ function runtimeClient(workspace) {
     }
   });
 }
-function authClient(workspace) {
+function createAuthClient(workspace, fetchImpl) {
+  if (workspace.opencodeApi !== "v2")
+    throw new GittermError("BAD_REQUEST", "Runtime OAuth connection management requires OpenCode v2; use inline credentials or a managed workspace with v1");
   const authorization = workspace.runtime.password ? `Basic ${Buffer.from(`opencode:${workspace.runtime.password}`).toString("base64")}` : undefined;
   return createOpencodeV2Client({
+    fetch: fetchImpl,
     baseUrl: workspace.runtime.url,
     directory: workspace.runtime.directory,
     headers: {
@@ -1553,17 +2801,6 @@ function authStatus(status) {
     return { status: "failed", message: status.message, ...common };
   return { status: status.status, ...common };
 }
-function mapStatus(status, errorName, assistantCompleted = true) {
-  if (errorName === "MessageAbortedError")
-    return "cancelled";
-  if (errorName)
-    return "failed";
-  if (assistantCompleted)
-    return "completed";
-  if (status?.type === "retry")
-    return "retrying";
-  return "running";
-}
 function pollTiming(wait, fallbackTimeoutMs) {
   const timeoutMs = wait.timeoutMs ?? fallbackTimeoutMs;
   const pollIntervalMs = wait.pollIntervalMs ?? 1000;
@@ -1575,15 +2812,6 @@ function pollTiming(wait, fallbackTimeoutMs) {
   }
   return { timeoutMs, pollIntervalMs };
 }
-function modelParts(model) {
-  if (!model)
-    return;
-  const separator = model.indexOf("/");
-  if (separator <= 0 || separator === model.length - 1) {
-    throw new Error('model must use the "provider/model" format');
-  }
-  return { providerID: model.slice(0, separator), modelID: model.slice(separator + 1) };
-}
 function validateEnvironmentVariables(values) {
   for (const key of Object.keys(values)) {
     if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) {
@@ -1618,15 +2846,18 @@ function setupRunner(commands) {
 }
 function createDirectGittermClient(options) {
   const provider = resolveProvider(options.provider);
+  const authClient = (workspace) => createAuthClient(workspace, options.fetch);
+  const http = (workspace) => createRuntimeHttp({
+    url: workspace.runtime.url,
+    directory: workspace.runtime.directory,
+    password: workspace.runtime.password ?? null,
+    api: workspace.opencodeApi,
+    headers: workspace.runtime.headers,
+    fetch: options.fetch
+  });
   function assertWorkspace(workspace) {
     if (workspace.provider !== provider.name) {
-      throw new Error(`Workspace belongs to ${workspace.provider}, not ${provider.name}`);
-    }
-  }
-  function assertRunWorkspace(run, workspace) {
-    assertWorkspace(workspace);
-    if (run.workspaceId !== workspace.id) {
-      throw new Error(`Run belongs to workspace ${run.workspaceId}, not ${workspace.id}`);
+      throw new GittermError("BAD_REQUEST", `Workspace belongs to ${workspace.provider}, not ${provider.name}`);
     }
   }
   function assertAuthAttempt(attempt, workspace) {
@@ -1644,55 +2875,29 @@ function createDirectGittermClient(options) {
       throw new Error(errorMessage(result.error));
     return authStatus(result.data.data);
   }
-  async function getRun(run, workspace) {
-    assertRunWorkspace(run, workspace);
-    const client = runtimeClient(workspace);
-    const [statuses, messages] = await Promise.all([
-      client.session.status({ query: { directory: workspace.runtime.directory } }),
-      client.session.messages({
-        path: { id: run.sessionId },
-        query: { directory: workspace.runtime.directory }
-      })
-    ]);
-    if (statuses.error || !statuses.data)
-      throw new Error(errorMessage(statuses.error));
-    if (messages.error || !messages.data)
-      throw new Error(errorMessage(messages.error));
-    const related = messages.data.filter((message) => message.info.id === run.messageId || message.info.role === "assistant" && message.info.parentID === run.messageId);
-    const assistant = related.findLast((message) => message.info.role === "assistant");
-    const assistantError = assistant?.info.role === "assistant" ? assistant.info.error : undefined;
-    const assistantCompleted = assistant?.info.role === "assistant" && assistant.info.time.completed != null;
-    const finalText = assistant?.parts.filter((part) => part.type === "text" && !part.ignored).map((part) => part.type === "text" ? part.text : "").join(`
-`).trim();
-    const sessionStatus = statuses.data[run.sessionId];
-    const status = assistant ? mapStatus(sessionStatus, assistantError?.name, Boolean(assistantCompleted)) : mapStatus(sessionStatus, undefined, false);
-    return {
-      ...run,
-      status,
-      error: assistantError ? errorMessage(assistantError) : null,
-      finalText: finalText || null
-    };
-  }
   async function startPty(workspace, command, title) {
-    const result = await authClient(workspace).pty.create({
-      command: "bash",
-      args: ["-lc", command],
-      cwd: workspace.runtime.directory,
-      directory: workspace.runtime.directory,
-      title
+    const result = await http(workspace).json(workspace.opencodeApi === "v2" ? "/api/pty" : `/pty?directory=${encodeURIComponent(workspace.runtime.directory)}`, {
+      method: "POST",
+      json: { command: "bash", args: ["-lc", command], cwd: workspace.runtime.directory, title }
     });
-    if (result.error || !result.data)
-      throw new Error(errorMessage(result.error));
-    return result.data;
+    return result;
   }
   async function setupFile(workspace, name) {
-    const result = await authClient(workspace).file.read({
-      directory: workspace.runtime.directory,
-      path: `${SETUP_DIR}/${name}`
-    });
-    if (result.error || !result.data || result.data.type !== "text")
-      return null;
-    return result.data.content.trim();
+    try {
+      if (workspace.opencodeApi === "v2") {
+        return (await (await http(workspace).send(`/api/fs/read/${SETUP_DIR}/${name}`)).text()).trim();
+      }
+      const result = await runtimeClient(workspace, options.fetch).file.read({
+        query: { directory: workspace.runtime.directory, path: `${SETUP_DIR}/${name}` }
+      });
+      if (result.error || !result.data || result.data.type !== "text")
+        return null;
+      return result.data.content.trim();
+    } catch (error) {
+      if (error instanceof RuntimeHttpError && error.status === 404)
+        return null;
+      throw directError(error);
+    }
   }
   async function getSetupStatus(workspace) {
     assertWorkspace(workspace);
@@ -1739,7 +2944,14 @@ function createDirectGittermClient(options) {
         if (!providerName) {
           throw new Error("Model credential providerName is required");
         }
-        const result = await runtimeClient(workspace).auth.set({
+        if (workspace.opencodeApi === "v2") {
+          if (credential.source !== "apiKey")
+            throw new GittermError("BAD_REQUEST", "Use connectOAuth() for v2 credential rotation, or inject an OAuth bundle when creating the workspace");
+          directModelAuth(credential);
+          await http(workspace).send(`/api/integration/${encodeURIComponent(providerName)}/connect/key`, { method: "POST", json: { key: credential.apiKey } });
+          return;
+        }
+        const result = await runtimeClient(workspace, options.fetch).auth.set({
           path: { id: providerName },
           query: { directory: workspace.runtime.directory },
           body: directModelAuth(credential)
@@ -1814,8 +3026,8 @@ function createDirectGittermClient(options) {
       async wait(attempt, workspace, wait = {}) {
         assertAuthAttempt(attempt, workspace);
         const { timeoutMs, pollIntervalMs } = pollTiming(wait, Math.max(0, attempt.expiresAt - Date.now()));
-        const deadline = Date.now() + timeoutMs;
-        while (Date.now() <= deadline) {
+        const deadline2 = Date.now() + timeoutMs;
+        while (Date.now() <= deadline2) {
           const status = await getAuthStatus(attempt, workspace);
           if (status.status === "complete")
             return status;
@@ -1823,7 +3035,7 @@ function createDirectGittermClient(options) {
             throw new Error(status.message);
           if (status.status === "expired")
             throw new Error("OAuth attempt expired");
-          const remaining = deadline - Date.now();
+          const remaining = deadline2 - Date.now();
           if (remaining <= 0)
             break;
           await new Promise((resolve) => setTimeout(resolve, Math.min(pollIntervalMs, remaining)));
@@ -1841,6 +3053,8 @@ function createDirectGittermClient(options) {
     },
     workspaces: {
       async create(input = {}) {
+        if (input.opencode?.api && !["v1", "v2"].includes(input.opencode.api))
+          throw new GittermError("BAD_REQUEST", "opencode.api must be v1 or v2");
         const lifecycle = input.lifecycle ?? provider.capabilities.recommendedLifecycle;
         if (lifecycle === "persistent" && provider.capabilities.persistence === "unsupported") {
           throw new Error(`${provider.name} does not support persistent direct workspaces`);
@@ -1857,6 +3071,7 @@ function createDirectGittermClient(options) {
           status: "running",
           lifecycle,
           runtime: created.runtime,
+          opencodeApi: input.opencode?.api ?? "v1",
           setup: provisioning.setup.afterAgent.length ? "after_agent" : provisioning.setup.beforeAgent.length ? "before_agent_complete" : "not_requested",
           createdAt: new Date().toISOString()
         };
@@ -1911,7 +3126,7 @@ function createDirectGittermClient(options) {
       setupStatus: getSetupStatus,
       async waitForSetup(workspace, wait = {}) {
         const { timeoutMs, pollIntervalMs } = pollTiming(wait, 10 * 60000);
-        const deadline = Date.now() + timeoutMs;
+        const deadline2 = Date.now() + timeoutMs;
         while (true) {
           const status = await getSetupStatus(workspace);
           if (status.status === "not_requested" || status.status === "succeeded")
@@ -1920,7 +3135,7 @@ function createDirectGittermClient(options) {
             throw new Error(`Workspace setup failed${status.exitCode == null ? "" : ` with exit code ${status.exitCode}`}${status.log ? `
 ${status.log}` : ""}`);
           }
-          if (Date.now() >= deadline) {
+          if (Date.now() >= deadline2) {
             throw new Error(`Workspace setup timed out after ${timeoutMs}ms`);
           }
           await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
@@ -1928,89 +3143,75 @@ ${status.log}` : ""}`);
       }
     },
     runs: {
+      ...directRunOperations(assertWorkspace, options.fetch),
       async create(input) {
         assertWorkspace(input.workspace);
-        const client = runtimeClient(input.workspace);
-        let sessionId = input.sessionId;
-        let title = input.title ?? "Agent run";
-        if (!sessionId) {
-          const created = await client.session.create({
-            body: input.title ? { title: input.title } : undefined,
-            query: { directory: input.workspace.runtime.directory }
-          });
-          if (created.error || !created.data)
-            throw new Error(errorMessage(created.error));
-          sessionId = created.data.id;
-          title = created.data.title;
+        aborted(input.signal);
+        if (input.workspace.status !== "running")
+          throw new GittermError("WORKSPACE_NOT_RUNNING", "Resume the workspace before creating a run");
+        if (!input.prompt.trim())
+          throw new GittermError("BAD_REQUEST", "Prompt is required");
+        if (input.model && !/^[^/]+\/.+$/.test(input.model))
+          throw new GittermError("BAD_REQUEST", "Model must use provider/model format");
+        if (input.waitForSetup) {
+          const deadline2 = Date.now() + (input.setupTimeoutMs ?? 10 * 60000);
+          while (true) {
+            aborted(input.signal);
+            const status = await getSetupStatus(input.workspace);
+            if (status.status === "succeeded" || status.status === "not_requested")
+              break;
+            if (status.status === "failed")
+              throw new GittermError("BAD_REQUEST", `Workspace setup failed: ${status.log ?? ""}`);
+            if (Date.now() >= deadline2)
+              throw new GittermError("TIMEOUT", "Workspace setup timed out");
+            await new Promise((resolve) => setTimeout(resolve, 1000));
+          }
+        }
+        const runtime = directRuntime(input.workspace, options.fetch);
+        const previous = input.context?.type === "continue" ? input.context.run : undefined;
+        if (previous && (previous.workspaceId !== input.workspace.id || !terminal(previous.status))) {
+          throw new GittermError("CONFLICT", "Continue a terminal run from the same workspace");
         }
+        let sessionId = previous?.sessionId;
+        let title = input.title ?? "Agent run";
+        const now = new Date().toISOString();
         const messageId = `msg_${randomUUID().replaceAll("-", "")}`;
-        const prompted = await client.session.promptAsync({
-          path: { id: sessionId },
-          query: { directory: input.workspace.runtime.directory },
-          body: {
-            messageID: messageId,
-            parts: [{ type: "text", text: input.prompt }],
-            agent: input.agent,
-            model: modelParts(input.model)
+        try {
+          aborted(input.signal);
+          if (!sessionId) {
+            const session2 = await runtime.createSession(input);
+            sessionId = session2.id;
+            title = session2.title;
           }
-        });
-        if (prompted.error)
-          throw new Error(errorMessage(prompted.error));
-        return {
-          id: randomUUID(),
-          workspaceId: input.workspace.id,
-          sessionId,
-          messageId,
-          title,
-          status: "running",
-          error: null,
-          finalText: null,
-          submittedAt: new Date().toISOString()
-        };
-      },
-      get: getRun,
-      async wait(run, workspace, wait = {}) {
-        const { timeoutMs, pollIntervalMs } = pollTiming(wait, 10 * 60000);
-        const deadline = Date.now() + timeoutMs;
-        let current = run;
-        while (Date.now() < deadline) {
-          current = await getRun(current, workspace);
-          if (!["running", "retrying"].includes(current.status))
-            return current;
-          const remaining = deadline - Date.now();
-          if (remaining <= 0)
-            break;
-          await new Promise((resolve) => setTimeout(resolve, Math.min(pollIntervalMs, remaining)));
+          aborted(input.signal);
+          await runtime.prompt({
+            sessionId,
+            messageId,
+            prompt: input.prompt,
+            agent: input.agent,
+            model: input.model
+          });
+          return {
+            id: randomUUID(),
+            workspaceId: input.workspace.id,
+            workspace: input.workspace,
+            sessionId,
+            messageId,
+            title,
+            status: "running",
+            error: null,
+            finalText: null,
+            pendingInputs: [],
+            context: previous ? { type: "continued", runId: previous.id } : { type: "isolated" },
+            createdAt: now,
+            submittedAt: now,
+            completedAt: null
+          };
+        } catch (error) {
+          if (sessionId && !previous)
+            await runtime.deleteSession(sessionId).catch(() => {});
+          throw directError(error);
         }
-        throw new Error(`Agent run timed out after ${timeoutMs}ms`);
-      },
-      async messages(run, workspace) {
-        assertRunWorkspace(run, workspace);
-        const result = await runtimeClient(workspace).session.messages({
-          path: { id: run.sessionId },
-          query: { directory: workspace.runtime.directory }
-        });
-        if (result.error || !result.data)
-          throw new Error(errorMessage(result.error));
-        return result.data.filter((message) => message.info.id === run.messageId || message.info.role === "assistant" && message.info.parentID === run.messageId).map((message) => ({
-          id: message.info.id,
-          role: message.info.role,
-          text: message.parts.filter((part) => part.type === "text" && !part.ignored).map((part) => part.type === "text" ? part.text : "").join(`
-`).trim(),
-          error: message.info.role === "assistant" && message.info.error ? errorMessage(message.info.error) : null
-        }));
-      },
-      async cancel(run, workspace) {
-        const current = await getRun(run, workspace);
-        if (!["running", "retrying"].includes(current.status))
-          return false;
-        const result = await runtimeClient(workspace).session.abort({
-          path: { id: run.sessionId },
-          query: { directory: workspace.runtime.directory }
-        });
-        if (result.error)
-          throw new Error(errorMessage(result.error));
-        return result.data === true;
       }
     }
   };