@zetaloop/chappie 0.5.0 → 1.0.0

package/dist/stdio-KJVCYPXJ.js

@@ -0,0 +1,1279 @@
+import { createRequire } from "node:module"; const require = createRequire(import.meta.url);
+import {
+  IpcServer,
+  source,
+  sourceLabel
+} from "./chunk-EIPDEA3I.js";
+import {
+  McpServer,
+  ResourceTemplate,
+  StdioServerTransport,
+  serveStdio
+} from "./chunk-K2VE2MDU.js";
+import "./chunk-GX4JWLHH.js";
+import {
+  package_default
+} from "./chunk-DN7OHZK6.js";
+import {
+  array,
+  boolean,
+  callInput,
+  callsInput,
+  chatInput,
+  deliveryContent,
+  getDirectory,
+  historyInput,
+  historyInstructions,
+  inputContent,
+  literal,
+  number,
+  object,
+  parseCalls,
+  readConfig,
+  resourceSessionId,
+  string,
+  toolResult,
+  transferDescription,
+  transferInput
+} from "./chunk-GWYP7B66.js";
+import "./chunk-UOFCCHBS.js";
+
+// src/broker.ts
+import { randomUUID } from "node:crypto";
+import { mkdir } from "node:fs/promises";
+
+// src/questions.ts
+var questionInstructions = "Use ask for questions in ChatGPT. Answers and revisions arrive as webAnswer with their target sessionId. Apply them to that task; a user skip means proceed with available information.";
+var questionInput = object({
+  header: string().trim().min(1).optional().describe("Short topic label"),
+  question: string().trim().min(1).describe("One focused question for the user"),
+  context: string().optional().describe("Background needed to answer the question"),
+  options: array(
+    object({
+      title: string().trim().min(1).describe("Short choice label"),
+      description: string().optional().describe("Brief consequence or tradeoff of this choice"),
+      recommended: boolean().optional().describe("Preferred choice; place it first")
+    })
+  ).default([]).describe(
+    "Distinct choices, usually two or three. Freeform answers and skipping are available separately."
+  ),
+  allowMultiple: boolean().default(false).describe("Allow selecting several options")
+});
+var answerInput = object({
+  selections: array(number().int().nonnegative()).default([]),
+  text: string().trim().default(""),
+  skipped: literal(true).optional().describe("The question was skipped")
+});
+var questionOutput = questionInput.extend({
+  id: string().describe("Generated question ID for ask_assert"),
+  sessionId: string(),
+  cwd: string(),
+  answer: answerInput.optional(),
+  loaded: boolean().optional().describe("The widget has reported loading")
+});
+function questionView(record) {
+  const { chatId: _chatId, delivered: _delivered, ...question } = record;
+  return question;
+}
+function answerContent(records) {
+  return records.map((record) => ({
+    type: "text",
+    text: JSON.stringify({
+      webAnswer: {
+        questionId: record.id,
+        sessionId: record.sessionId,
+        cwd: record.cwd,
+        header: record.header,
+        question: record.question,
+        skipped: record.answer?.skipped,
+        choices: record.answer?.selections.map(
+          (index) => record.options[index]
+        ),
+        text: record.answer?.text
+      }
+    })
+  }));
+}
+
+// src/state.ts
+import { readFile, rename, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+var State = class {
+  #path;
+  #temporaryPath;
+  #bindings = /* @__PURE__ */ new Map();
+  #deliveries = /* @__PURE__ */ new Map();
+  #questions = /* @__PURE__ */ new Map();
+  #writes = Promise.resolve();
+  constructor(directory) {
+    this.#path = join(directory, "state.json");
+    this.#temporaryPath = `${this.#path}.tmp`;
+  }
+  async load() {
+    let contents;
+    try {
+      contents = await readFile(this.#path, "utf8");
+    } catch (error) {
+      if (error.code === "ENOENT") return;
+      throw error;
+    }
+    const state = JSON.parse(contents);
+    for (const [chatId, sessionId] of Object.entries(state.bindings ?? {})) {
+      if (typeof sessionId === "string") this.#bindings.set(chatId, sessionId);
+    }
+    for (const delivery of state.deliveries ?? []) {
+      if (delivery?.id) this.#deliveries.set(delivery.id, delivery);
+    }
+    for (const question of state.questions ?? [])
+      this.#questions.set(question.id, question);
+  }
+  binding(chatId) {
+    return this.#bindings.get(chatId);
+  }
+  bindingCounts() {
+    const counts = /* @__PURE__ */ new Map();
+    for (const sessionId of this.#bindings.values()) {
+      counts.set(sessionId, (counts.get(sessionId) ?? 0) + 1);
+    }
+    return counts;
+  }
+  bind(chatId, sessionId) {
+    this.#bindings.set(chatId, sessionId);
+    return this.#save();
+  }
+  deliveries(chatId) {
+    return [...this.#deliveries.values()].filter(
+      (delivery) => delivery.clientId === chatId
+    );
+  }
+  addDelivery(delivery) {
+    this.#deliveries.set(delivery.id, delivery);
+    return this.#save();
+  }
+  question(chatId, id) {
+    const question = this.#questions.get(id);
+    if (!question || question.chatId !== chatId)
+      throw new Error("Question not found in this ChatGPT conversation");
+    return question;
+  }
+  async addQuestion(question) {
+    this.#questions.set(question.id, question);
+    await this.#save();
+  }
+  async answer(chatId, id, answer) {
+    const question = this.question(chatId, id);
+    const selections = [...new Set(answer.selections)].sort((a, b) => a - b);
+    if (selections.some((index) => !question.options[index]))
+      throw new Error("Unknown question option");
+    if (!question.allowMultiple && selections.length > 1)
+      throw new Error("Select one option");
+    if (answer.skipped && (selections.length > 0 || answer.text))
+      throw new Error("A skipped question cannot include an answer");
+    if (!answer.skipped && selections.length === 0 && !answer.text)
+      throw new Error("Select an option or enter an answer");
+    const value = {
+      selections,
+      text: answer.text,
+      ...answer.skipped ? { skipped: true } : {}
+    };
+    if (JSON.stringify(question.answer) === JSON.stringify(value))
+      return question;
+    const updated = { ...question, answer: value, delivered: false };
+    await this.addQuestion(updated);
+    return updated;
+  }
+  answers(chatId) {
+    return [...this.#questions.values()].filter(
+      (question) => question.chatId === chatId && question.answer && !question.delivered
+    );
+  }
+  async acknowledge(deliveries, answers, signal) {
+    if (deliveries.length === 0 && answers.length === 0) return;
+    signal.throwIfAborted();
+    const delivered = new Map(
+      answers.map((question) => [question, { ...question, delivered: true }])
+    );
+    for (const delivery of deliveries) this.#deliveries.delete(delivery.id);
+    for (const [question, updated] of delivered) {
+      if (this.#questions.get(question.id) === question)
+        this.#questions.set(question.id, updated);
+    }
+    try {
+      await this.#save();
+      signal.throwIfAborted();
+    } catch (error) {
+      for (const delivery of deliveries)
+        this.#deliveries.set(delivery.id, delivery);
+      for (const [question, updated] of delivered) {
+        if (this.#questions.get(question.id) === updated)
+          this.#questions.set(question.id, question);
+      }
+      await this.#save();
+      throw error;
+    }
+  }
+  #save() {
+    const saved = this.#writes.then(async () => {
+      const bindings = Object.fromEntries(this.#bindings);
+      await writeFile(
+        this.#temporaryPath,
+        `${JSON.stringify({ bindings, deliveries: [...this.#deliveries.values()], questions: [...this.#questions.values()] }, null, 2)}
+`,
+        {
+          mode: 384
+        }
+      );
+      await rename(this.#temporaryPath, this.#path);
+    });
+    this.#writes = saved.catch(() => {
+    });
+    return saved;
+  }
+};
+
+// src/broker.ts
+var observerInstructions = "This conversation recently interacted with this session. Participate as an observer for this task: follow progress through history with observer: true, then explain the recorded outcome in ChatGPT.";
+var Broker = class {
+  #directory;
+  #ipc;
+  #state;
+  #sessions = /* @__PURE__ */ new Map();
+  #resources = /* @__PURE__ */ new Map();
+  #pending = /* @__PURE__ */ new Map();
+  #waiters = /* @__PURE__ */ new Set();
+  #cooldowns = /* @__PURE__ */ new Map();
+  #relays = /* @__PURE__ */ new Map();
+  #config = {};
+  #nextRequestId = 1;
+  constructor(directory) {
+    this.#directory = directory;
+    this.#state = new State(directory);
+    this.#ipc = new IpcServer(
+      directory,
+      (peer, message) => this.#receive(peer, message),
+      (peer) => this.#removePeer(peer)
+    );
+  }
+  async start() {
+    this.#config = await readConfig(this.#directory);
+    await mkdir(this.#directory, { recursive: true });
+    await this.#state.load();
+    await this.#ipc.start(this.#config.listen ?? false);
+  }
+  async close() {
+    const error = new Error("Chappie broker ended");
+    this.#cooldowns.clear();
+    for (const relays of this.#relays.values()) {
+      for (const controller of relays.values()) controller.abort(error);
+    }
+    this.#relays.clear();
+    for (const [id, pending] of this.#pending) {
+      this.#finishRequest(id, pending);
+      pending.reject(error);
+    }
+    for (const waiter of this.#waiters) {
+      waiter.signal.removeEventListener("abort", waiter.onAbort);
+      waiter.reject(error);
+    }
+    this.#waiters.clear();
+    this.#sessions.clear();
+    this.#resources.clear();
+    await this.#ipc.close();
+  }
+  listSessions(sessionId) {
+    const counts = this.#state.bindingCounts();
+    return [...this.#sessions.values()].filter(({ description }) => !sessionId || description.id === sessionId).map(({ description }) => ({
+      ...description,
+      bindingCount: counts.get(description.id) ?? 0
+    }));
+  }
+  get askEnabled() {
+    return this.#config.ask ?? true;
+  }
+  binding(chatId) {
+    return this.#state.binding(chatId);
+  }
+  async initialize(chatId, sessionId, requestId, signal) {
+    const {
+      sessionId: target,
+      selection,
+      initialization
+    } = await this.#selectSession(chatId, sessionId, requestId, signal, true);
+    const { inspection, inputs, globalAgents } = await this.#inspect(
+      target,
+      signal
+    );
+    await this.#ackInputs(target, inputs, signal);
+    return {
+      selection,
+      ...initialization ? { initialization } : {},
+      ...inspection,
+      tools: inspection.tools.map(({ name, description }) => ({
+        name,
+        description: description.split("\n", 1)[0] ?? description
+      })),
+      inputs,
+      ...globalAgents ? { globalAgents } : {}
+    };
+  }
+  async chat(chatId, sessionId, text, requestId, signal, replyTo) {
+    const { sessionId: target, initialization } = await this.#selectSession(
+      chatId,
+      sessionId,
+      requestId,
+      signal
+    );
+    const result = await this.#request(
+      target,
+      (id) => ({
+        type: "chat",
+        id,
+        ...source(chatId, requestId),
+        sessionId: target,
+        text,
+        ...replyTo ? { replyTo } : {}
+      }),
+      signal
+    );
+    if ("message" in result || "cancelled" in result) {
+      const inputs = result.inputs;
+      await this.#ackInputs(target, inputs, signal);
+      return {
+        sessionId: target,
+        cwd: result.cwd,
+        inputs,
+        ...initialization ? { initialization } : {},
+        ..."cancelled" in result ? { cancelled: result.cancelled } : {}
+      };
+    }
+    throw new Error("Session returned no assistant message");
+  }
+  async tools(chatId, sessionId, names, requestId, signal) {
+    const { sessionId: target, initialization } = await this.#selectSession(
+      chatId,
+      sessionId,
+      requestId,
+      signal
+    );
+    const { inspection, inputs } = await this.#inspect(target, signal);
+    await this.#ackInputs(target, inputs, signal);
+    const selected = names ? new Set(names) : void 0;
+    return {
+      ...inspection,
+      ...initialization ? { initialization } : {},
+      tools: selected ? inspection.tools.filter(({ name }) => selected.has(name)) : inspection.tools,
+      inputs
+    };
+  }
+  async call(chatId, sessionId, calls, requestId, signal) {
+    const { sessionId: target, initialization } = await this.#selectSession(
+      chatId,
+      sessionId,
+      requestId,
+      signal
+    );
+    const toolCalls = calls.map((call) => ({
+      type: "toolCall",
+      id: `chappie-${randomUUID()}`,
+      name: call.name,
+      arguments: call.arguments
+    }));
+    const result = await this.#request(
+      target,
+      (id) => ({
+        type: "call",
+        id,
+        ...source(chatId, requestId),
+        sessionId: target,
+        calls: toolCalls
+      }),
+      signal
+    );
+    if ("toolResults" in result) {
+      await this.#ackInputs(target, result.inputs, signal);
+      return {
+        sessionId: target,
+        ...initialization ? { initialization } : {},
+        cwd: result.cwd,
+        toolResults: result.toolResults,
+        inputs: result.inputs,
+        ..."cancelled" in result ? { cancelled: result.cancelled } : {}
+      };
+    }
+    throw new Error("Session returned no tool results");
+  }
+  async history(chatId, sessionId, range, requestId, signal) {
+    const target = sessionId ?? this.#state.binding(chatId);
+    if (!target) throw new Error("Specify a sessionId to read history");
+    await this.#waitForSession(target, signal);
+    const result = await this.#request(
+      target,
+      (id) => ({
+        type: "history",
+        id,
+        sessionId: target,
+        range,
+        ...source(chatId, requestId)
+      }),
+      signal
+    );
+    if ("history" in result) return { sessionId: target, ...result };
+    throw new Error("Session returned no history");
+  }
+  async inputs(chatId, sessionId, signal) {
+    const target = sessionId ?? this.#state.binding(chatId);
+    if (!target || !this.#sessions.has(target)) return [];
+    const result = await this.#request(
+      target,
+      (id) => ({ type: "inputs", id, sessionId: target }),
+      signal
+    );
+    if (!("inputs" in result)) throw new Error("Session returned no inputs");
+    await this.#ackInputs(target, result.inputs, signal);
+    return result.inputs;
+  }
+  async ask(chatId, sessionId, input, requestId, signal) {
+    const { sessionId: target, initialization } = await this.#selectSession(
+      chatId,
+      sessionId,
+      requestId,
+      signal
+    );
+    signal.throwIfAborted();
+    const session = this.#sessions.get(target);
+    if (!session) throw new Error(`Session ${target} is offline`);
+    const question = {
+      ...input,
+      id: randomUUID(),
+      chatId,
+      sessionId: target,
+      cwd: session.description.cwd,
+      delivered: false
+    };
+    await this.#state.addQuestion(question);
+    const activity = source(chatId, requestId);
+    void this.#notify(
+      target,
+      `${sourceLabel(activity)} asked: ${question.question}`,
+      {
+        event: "asked",
+        ...activity
+      }
+    ).catch(() => {
+    });
+    return {
+      ...questionView(question),
+      ...initialization ? { initialization } : {}
+    };
+  }
+  async assertQuestion(chatId, id, signal) {
+    const timeout = AbortSignal.timeout(1e4);
+    const combined = AbortSignal.any([signal, timeout]);
+    try {
+      for (; ; ) {
+        signal.throwIfAborted();
+        const question = this.#state.question(chatId, id);
+        if (question.loaded) return questionView(question);
+        await this.#waitForChange(combined);
+      }
+    } catch (error) {
+      signal.throwIfAborted();
+      if (!timeout.aborted) throw error;
+      const question = this.#state.question(chatId, id);
+      if (question.loaded) return questionView(question);
+      if (!question.answer) {
+        await this.#state.answer(chatId, id, {
+          selections: [],
+          text: "",
+          skipped: true
+        });
+        void this.#notify(
+          question.sessionId,
+          `Question skipped after display timeout: ${question.question}`,
+          { event: "skipped", clientId: chatId }
+        ).catch(() => {
+        });
+      }
+      throw new Error(
+        "Question widget did not load within 10 seconds. The question was automatically skipped. Use an installed native interactive tool through call if an answer is needed."
+      );
+    }
+  }
+  async answer(chatId, id, answer, loaded = false) {
+    let question = this.#state.question(chatId, id);
+    if ((loaded || answer) && !question.loaded) {
+      this.#cooldown(chatId, question.sessionId);
+      question = { ...question, loaded: true };
+      await this.#state.addQuestion(question);
+      this.#notifyChange();
+    }
+    if (answer) {
+      const previous = question.answer;
+      question = await this.#state.answer(chatId, id, answer);
+      if (question.answer !== previous) {
+        const response = [
+          ...(question.answer?.selections ?? []).map(
+            (index) => question.options[index]?.title
+          ),
+          question.answer?.text
+        ].filter(Boolean).join(", ");
+        const message = question.answer?.skipped ? `Skipped in ChatGPT ${chatId.slice(-4)}: ${question.question}` : previous ? `Answer updated in ChatGPT ${chatId.slice(-4)}: ${question.question} \u2014 ${response}` : `Answered in ChatGPT ${chatId.slice(-4)}: ${question.question} \u2014 ${response}`;
+        void this.#notify(question.sessionId, message, {
+          event: question.answer?.skipped ? "skipped" : "answered",
+          clientId: chatId
+        }).catch(() => {
+        });
+      }
+    }
+    return questionView(question);
+  }
+  answers(chatId) {
+    return this.#state.answers(chatId);
+  }
+  async readResource(uri, signal) {
+    const requested = new URL(uri);
+    const chatId = requested.searchParams.get("chatId");
+    requested.search = "";
+    const sessionId = resourceSessionId(requested.href);
+    if (chatId) this.#cooldown(chatId, sessionId);
+    const result = await this.#request(
+      sessionId,
+      (id) => ({ type: "readResource", id, sessionId, uri: requested.href }),
+      signal
+    );
+    if ("resource" in result) {
+      if (chatId) this.#cooldown(chatId, sessionId);
+      return { ...result.resource, uri };
+    }
+    throw new Error("Session returned no resource");
+  }
+  deliveries(chatId) {
+    return this.#state.deliveries(chatId);
+  }
+  acknowledge(deliveries, answers, signal) {
+    return this.#state.acknowledge(deliveries, answers, signal);
+  }
+  async request(request, signal) {
+    if (request.type === "sessions")
+      return { sessions: this.listSessions(request.sessionId) };
+    const result = await this.#request(
+      request.sessionId,
+      (id) => ({ ...request, id }),
+      signal
+    );
+    if ("inputs" in result)
+      await this.#ackInputs(request.sessionId, result.inputs, signal);
+    return result;
+  }
+  async #receive(peer, message) {
+    switch (message.type) {
+      case "request": {
+        let relays = this.#relays.get(peer);
+        if (!relays) {
+          relays = /* @__PURE__ */ new Map();
+          this.#relays.set(peer, relays);
+        }
+        const controller = new AbortController();
+        relays.set(message.id, controller);
+        void this.request(message.request, controller.signal).then(
+          async (result) => {
+            const deliveries = this.#state.deliveries(message.clientId);
+            await peer.send({
+              ...result,
+              type: "response",
+              id: message.id,
+              ...deliveries.length ? { deliveries } : {}
+            });
+            await this.#state.acknowledge(deliveries, [], controller.signal);
+          },
+          (error) => peer.send({
+            type: "response",
+            id: message.id,
+            error: error instanceof Error ? error.message : String(error)
+          })
+        ).finally(() => relays.delete(message.id)).catch(() => {
+        });
+        break;
+      }
+      case "resources":
+        for (const resource of message.resources)
+          this.#resources.set(resource.uri, peer);
+        break;
+      case "cancelRequest":
+        this.#relays.get(peer)?.get(message.id)?.abort(new Error("Request cancelled"));
+        break;
+      case "sync": {
+        const registered = this.#sessions.get(message.session.id)?.peer === peer;
+        this.#sessions.set(message.session.id, {
+          description: message.session,
+          peer
+        });
+        await peer.send({
+          type: "synced",
+          id: message.id,
+          sessionId: message.session.id
+        });
+        if (!registered)
+          await this.#notify(message.session.id, "Chappie connected", {
+            event: "connected"
+          });
+        this.#notifyChange();
+        break;
+      }
+      case "unregister": {
+        const session = this.#sessions.get(message.sessionId);
+        if (session?.peer === peer) this.#removeSession(message.sessionId);
+        break;
+      }
+      case "delivery":
+        await this.#state.addDelivery(message.delivery);
+        await peer.send({ type: "stored", id: message.delivery.id });
+        break;
+      case "result": {
+        const pending = this.#pending.get(message.id);
+        if (!pending || pending.peer !== peer) break;
+        this.#finishRequest(message.id, pending);
+        if ("error" in message) pending.reject(new Error(message.error));
+        else {
+          const { type: _type, id: _id, ...result } = message;
+          pending.resolve(result);
+        }
+        break;
+      }
+    }
+  }
+  async #selectSession(chatId, requestedId, requestId, signal, bindRequested = false) {
+    for (; ; ) {
+      signal.throwIfAborted();
+      const boundId = this.#state.binding(chatId);
+      let target = requestedId ?? boundId;
+      if (!target) {
+        const occupied = this.#state.bindingCounts();
+        target = [...this.#sessions.keys()].find((id) => !occupied.has(id));
+      }
+      if (!target) {
+        await this.#waitForChange(signal);
+        continue;
+      }
+      await this.#waitForSession(target, signal);
+      signal.throwIfAborted();
+      const initialization = bindRequested || !this.#state.binding(chatId) ? await this.#join(chatId, target, requestId, signal, bindRequested) : void 0;
+      return {
+        sessionId: target,
+        selection: requestedId ? "explicit" : boundId ? "existing" : "automatic",
+        ...initialization ? { initialization } : {}
+      };
+    }
+  }
+  async #join(chatId, sessionId, requestId, signal, explicit = false) {
+    signal.throwIfAborted();
+    const previous = this.#state.binding(chatId);
+    const key = JSON.stringify([chatId, sessionId]);
+    const observer = (this.#cooldowns.get(key) ?? 0) > Date.now();
+    if (!observer) this.#cooldown(chatId, sessionId);
+    await this.#state.bind(chatId, sessionId);
+    signal.throwIfAborted();
+    const activity = source(chatId, requestId);
+    if (previous !== sessionId) {
+      this.#notifyChange();
+      if (previous)
+        await this.#notify(previous, `${sourceLabel(activity)} left`, {
+          ...activity,
+          event: "left"
+        });
+    }
+    signal.throwIfAborted();
+    await this.#notify(sessionId, `${sourceLabel(activity)} joined`, {
+      ...activity,
+      event: "joined",
+      initialization: explicit ? "explicit" : "implicit"
+    });
+    return {
+      sessionId,
+      instructions: observer ? observerInstructions : historyInstructions
+    };
+  }
+  #cooldown(chatId, sessionId) {
+    const now = Date.now();
+    for (const [key, expires] of this.#cooldowns) {
+      if (expires <= now) this.#cooldowns.delete(key);
+    }
+    this.#cooldowns.set(
+      JSON.stringify([chatId, sessionId]),
+      now + (this.#config.cooldown ?? 20) * 1e3
+    );
+  }
+  async #notify(sessionId, message, activity = {}) {
+    await this.#sessions.get(sessionId)?.peer.send({ type: "notice", sessionId, message, activity });
+  }
+  async #waitForSession(sessionId, signal) {
+    while (!this.#sessions.has(sessionId)) await this.#waitForChange(signal);
+  }
+  async #inspect(sessionId, signal) {
+    const result = await this.#request(
+      sessionId,
+      (id) => ({ type: "inspect", id, sessionId }),
+      signal
+    );
+    if ("inspection" in result) return result;
+    throw new Error("Session returned no inspection");
+  }
+  async #ackInputs(sessionId, inputs, signal) {
+    signal.throwIfAborted();
+    if (inputs.length === 0) return;
+    const session = this.#sessions.get(sessionId);
+    if (!session) throw new Error(`Session ${sessionId} is offline`);
+    await session.peer.send({
+      type: "ackInputs",
+      sessionId,
+      ids: inputs.map(({ id }) => id)
+    });
+  }
+  async #request(sessionId, message, signal) {
+    if (signal.aborted) throw abortError(signal);
+    const id = this.#nextRequestId++;
+    const request = message(id);
+    const peer = request.type === "readResource" ? this.#resources.get(request.uri) : this.#sessions.get(sessionId)?.peer;
+    if (!peer)
+      throw new Error(
+        `Session resource or target is unavailable: ${sessionId}`
+      );
+    const completion = Promise.withResolvers();
+    const onAbort = () => {
+      const pending2 = this.#pending.get(id);
+      if (!pending2) return;
+      void pending2.peer.send({
+        type: "cancel",
+        id,
+        sessionId,
+        reason: abortError(signal).message
+      }).catch(() => {
+      });
+      this.#finishRequest(id, pending2);
+      pending2.reject(abortError(signal));
+    };
+    const pending = {
+      peer,
+      resolve: completion.resolve,
+      reject: completion.reject,
+      signal,
+      onAbort
+    };
+    this.#pending.set(id, pending);
+    signal.addEventListener("abort", onAbort, { once: true });
+    void peer.send(request).catch((error) => {
+      this.#finishRequest(id, pending);
+      pending.reject(error instanceof Error ? error : new Error(String(error)));
+    });
+    return completion.promise;
+  }
+  #waitForChange(signal) {
+    if (signal.aborted) return Promise.reject(abortError(signal));
+    const completion = Promise.withResolvers();
+    const onAbort = () => {
+      this.#waiters.delete(waiter);
+      waiter.reject(abortError(signal));
+    };
+    const waiter = {
+      resolve: completion.resolve,
+      reject: completion.reject,
+      signal,
+      onAbort
+    };
+    this.#waiters.add(waiter);
+    signal.addEventListener("abort", onAbort, { once: true });
+    return completion.promise;
+  }
+  #notifyChange() {
+    for (const waiter of this.#waiters) {
+      this.#waiters.delete(waiter);
+      waiter.signal.removeEventListener("abort", waiter.onAbort);
+      waiter.resolve();
+    }
+  }
+  #finishRequest(id, pending) {
+    this.#pending.delete(id);
+    pending.signal.removeEventListener("abort", pending.onAbort);
+  }
+  #removePeer(peer) {
+    for (const controller of this.#relays.get(peer)?.values() ?? []) {
+      controller.abort(new Error("Session disconnected"));
+    }
+    this.#relays.delete(peer);
+    for (const [uri, owner] of this.#resources) {
+      if (owner === peer) this.#resources.delete(uri);
+    }
+    for (const [sessionId, session] of this.#sessions) {
+      if (session.peer === peer) this.#removeSession(sessionId);
+    }
+    for (const [id, pending] of this.#pending) {
+      if (pending.peer !== peer) continue;
+      this.#finishRequest(id, pending);
+      pending.reject(new Error("Session disconnected"));
+    }
+  }
+  #removeSession(sessionId) {
+    this.#sessions.delete(sessionId);
+    this.#notifyChange();
+  }
+};
+function abortError(signal) {
+  return signal.reason instanceof Error ? signal.reason : new Error(
+    typeof signal.reason === "string" ? signal.reason : "Request cancelled"
+  );
+}
+
+// src/server.ts
+import { readFileSync } from "node:fs";
+var instructions = readFileSync(
+  new URL("./instructions.md", import.meta.url),
+  "utf8"
+).trim();
+var outputSchema = object({
+  text: string().describe(
+    "Tool output and session updates. Images and file resources accompany the text as content blocks."
+  )
+});
+var questionTemplate = "ui://chappie/question.html";
+var questionSchema = outputSchema.extend({ question: questionOutput });
+var toolAnnotations = {
+  readOnlyHint: true,
+  destructiveHint: false,
+  idempotentHint: true,
+  openWorldHint: false
+};
+function createServer(broker) {
+  const server = new McpServer(
+    {
+      name: "chappie",
+      version: package_default.version
+    },
+    {
+      instructions: [
+        instructions,
+        ...broker.askEnabled ? [questionInstructions] : []
+      ].join("\n\n")
+    }
+  );
+  function handle(callback) {
+    return (args, context) => {
+      const chatId = requireChatId(context);
+      context.mcpReq.signal.throwIfAborted();
+      return callback(args, { chatId, mcpReq: context.mcpReq });
+    };
+  }
+  server.registerTool(
+    "init",
+    {
+      title: "Connect to a session",
+      description: "Select the default session for this conversation and return its environment, tool catalog, and participation instructions.",
+      outputSchema,
+      inputSchema: object({
+        sessionId: string().optional().describe(
+          "Session to select; omit to reuse the default or choose an online unbound session"
+        )
+      }),
+      annotations: toolAnnotations
+    },
+    handle(async (args, context) => {
+      const { inputs, ...initialized } = await broker.initialize(
+        context.chatId,
+        args.sessionId,
+        context.mcpReq._meta?.["otunnel/requestId"],
+        context.mcpReq.signal
+      );
+      return finishResult(broker, context, textResult(initialized, inputs));
+    })
+  );
+  server.registerTool(
+    "chat",
+    {
+      title: "Reply in the session",
+      description: "Send a Markdown assistant message, or reply to a model request using its request ID as replyTo.",
+      outputSchema,
+      inputSchema: chatInput.extend({
+        sessionId: string().optional().describe(
+          "session for this operation; becomes the default if none is set"
+        )
+      }),
+      annotations: toolAnnotations
+    },
+    handle(async (args, context) => {
+      const result = await broker.chat(
+        context.chatId,
+        args.sessionId,
+        args.text,
+        context.mcpReq._meta?.["otunnel/requestId"],
+        context.mcpReq.signal,
+        args.replyTo
+      );
+      return finishResult(broker, context, toolResult(result));
+    })
+  );
+  if (broker.askEnabled) {
+    server.registerTool(
+      "ask",
+      {
+        title: "Ask in ChatGPT",
+        description: "Ask a question in ChatGPT. Call ask_assert next with question.id to confirm display; answers arrive as webAnswer.",
+        inputSchema: questionInput.extend({
+          sessionId: string().optional().describe(
+            "session for this question; defaults to this chat's session"
+          )
+        }),
+        outputSchema: questionSchema,
+        annotations: toolAnnotations,
+        _meta: { ui: { resourceUri: questionTemplate } }
+      },
+      handle(async ({ sessionId, ...input }, context) => {
+        const { initialization, ...question } = await broker.ask(
+          context.chatId,
+          sessionId,
+          input,
+          context.mcpReq._meta?.["otunnel/requestId"],
+          context.mcpReq.signal
+        );
+        const result = await finishResult(broker, context, {
+          content: [
+            ...initialization ? textResult({ initialization }).content : [],
+            {
+              type: "text",
+              text: `Question widget requested. Call ask_assert({"questionId":"${question.id}"}) next.`
+            }
+          ]
+        });
+        return {
+          ...result,
+          structuredContent: { ...result.structuredContent, question }
+        };
+      })
+    );
+    server.registerTool(
+      "ask_assert",
+      {
+        title: "Confirm question display",
+        description: "Confirm that an ask widget loaded. Call immediately after ask with question.id. Fails after 10 seconds and marks an unanswered question skipped; answers arrive separately as webAnswer.",
+        inputSchema: object({
+          questionId: string().describe("question.id returned by ask")
+        }),
+        outputSchema: questionSchema,
+        annotations: toolAnnotations
+      },
+      handle(async ({ questionId }, context) => {
+        const question = await broker.assertQuestion(
+          context.chatId,
+          questionId,
+          context.mcpReq.signal
+        );
+        const result = await finishResult(broker, context, {
+          content: [{ type: "text", text: "Question widget loaded." }]
+        });
+        return {
+          ...result,
+          structuredContent: { ...result.structuredContent, question }
+        };
+      })
+    );
+    server.registerTool(
+      "answer",
+      {
+        title: "Question state",
+        description: "Read a saved question, report widget loading, or save an answer, revision, or skip.",
+        inputSchema: object({
+          questionId: string(),
+          answer: answerInput.optional(),
+          loaded: literal(true).optional().describe("The question widget has loaded")
+        }),
+        outputSchema: questionSchema,
+        annotations: toolAnnotations,
+        _meta: { ui: { visibility: ["app"] }, "openai/widgetAccessible": true }
+      },
+      async ({ questionId, answer, loaded = false }, context) => {
+        const question = await broker.answer(
+          requireChatId(context),
+          questionId,
+          answer,
+          loaded
+        );
+        const text = answer ? answer.skipped ? "Question skipped." : "Answer saved." : loaded ? "Question widget loaded." : "Question state.";
+        return {
+          content: [{ type: "text", text }],
+          structuredContent: { text, question }
+        };
+      }
+    );
+    server.registerResource(
+      "question",
+      questionTemplate,
+      { title: "Chappie question", mimeType: "text/html;profile=mcp-app" },
+      async () => ({
+        contents: [
+          {
+            uri: questionTemplate,
+            mimeType: "text/html;profile=mcp-app",
+            text: readFileSync(
+              new URL("./question.html", import.meta.url),
+              "utf8"
+            ),
+            _meta: {
+              ui: {
+                prefersBorder: true,
+                csp: { connectDomains: [], resourceDomains: [] }
+              },
+              "openai/widgetDescription": "A question the user can answer or revise."
+            }
+          }
+        ]
+      })
+    );
+  }
+  server.registerTool(
+    "tools",
+    {
+      title: "Native tools",
+      description: "Get full definitions of native tools for call. Filter by names, or omit names to list all active tools.",
+      outputSchema,
+      inputSchema: object({
+        names: array(string()).min(1).optional().describe("Tool names to describe; omit to return every active tool"),
+        sessionId: string().optional().describe(
+          "session for this operation; becomes the default if none is set"
+        )
+      }),
+      annotations: toolAnnotations
+    },
+    handle(async (args, context) => {
+      const { inputs, ...inspected } = await broker.tools(
+        context.chatId,
+        args.sessionId,
+        args.names,
+        context.mcpReq._meta?.["otunnel/requestId"],
+        context.mcpReq.signal
+      );
+      return finishResult(
+        broker,
+        context,
+        textResult(
+          {
+            session: inspected.session,
+            tools: inspected.tools,
+            ...inspected.initialization ? { initialization: inspected.initialization } : {}
+          },
+          inputs
+        )
+      );
+    })
+  );
+  server.registerTool(
+    "call",
+    {
+      title: "Run native tools",
+      description: "Run one native tool batch using the definitions returned by tools.",
+      outputSchema,
+      inputSchema: callInput.safeExtend({
+        sessionId: string().optional().describe(
+          "session for this operation; becomes the default if none is set"
+        )
+      }),
+      annotations: toolAnnotations
+    },
+    handle(async (args, context) => {
+      const result = await broker.call(
+        context.chatId,
+        args.sessionId,
+        parseCalls(args),
+        context.mcpReq._meta?.["otunnel/requestId"],
+        context.mcpReq.signal
+      );
+      return finishResult(broker, context, toolResult(result));
+    })
+  );
+  server.registerTool(
+    "transfer",
+    {
+      title: "Transfer files",
+      description: transferDescription,
+      outputSchema,
+      inputSchema: transferInput.extend({
+        sessionId: string().optional().describe(
+          "Session for this operation; defaults to this chat's session"
+        )
+      }),
+      annotations: toolAnnotations,
+      _meta: { "openai/fileParams": ["files"] }
+    },
+    handle(async ({ sessionId, ...input }, context) => {
+      const result = await broker.call(
+        context.chatId,
+        sessionId,
+        callsInput.parse([{ name: "transfer", arguments: input }]),
+        context.mcpReq._meta?.["otunnel/requestId"],
+        context.mcpReq.signal
+      );
+      return finishResult(broker, context, toolResult(result));
+    })
+  );
+  server.registerTool(
+    "history",
+    {
+      title: "Session history",
+      description: "Read the current native transcript, including ongoing work. Re-read a range to see updates to existing entries.",
+      inputSchema: historyInput.extend({
+        sessionId: string().optional().describe("session to read; defaults to this chat's session")
+      }),
+      outputSchema,
+      annotations: toolAnnotations
+    },
+    handle(async ({ sessionId, ...range }, context) => {
+      const { history, ...session } = await broker.history(
+        context.chatId,
+        sessionId,
+        range,
+        context.mcpReq._meta?.["otunnel/requestId"],
+        context.mcpReq.signal
+      );
+      const { content, ...page } = history;
+      return formatResult(
+        {
+          content: [
+            ...textResult({ ...session, history: page }).content,
+            ...content
+          ]
+        },
+        context.chatId
+      );
+    })
+  );
+  server.registerTool(
+    "sessions",
+    {
+      title: "Sessions",
+      description: "List online Chappie sessions and this conversation's default target.",
+      outputSchema,
+      inputSchema: object({
+        sessionId: string().optional().describe("Filter the online list to this session")
+      }),
+      annotations: toolAnnotations
+    },
+    handle(async (args, context) => {
+      const { chatId } = context;
+      const inputs = await broker.inputs(
+        chatId,
+        args.sessionId,
+        context.mcpReq.signal
+      );
+      const result = textResult(
+        {
+          binding: broker.binding(chatId) ?? null,
+          sessions: broker.listSessions(args.sessionId)
+        },
+        inputs
+      );
+      return finishResult(broker, context, result);
+    })
+  );
+  server.registerResource(
+    "Session resource",
+    new ResourceTemplate(
+      "chappie://session/{sessionId}/{kind}/{id}/{name}{?chatId}",
+      {
+        list: void 0
+      }
+    ),
+    { title: "Session resource" },
+    async (uri, _variables, context) => {
+      const resource = await broker.readResource(
+        uri.href,
+        context.mcpReq.signal
+      );
+      return {
+        contents: [
+          {
+            uri: resource.uri,
+            mimeType: resource.mimeType,
+            blob: resource.blob
+          }
+        ]
+      };
+    }
+  );
+  return server;
+}
+function textResult(value, inputs = []) {
+  return {
+    content: [
+      { type: "text", text: JSON.stringify(value) },
+      ...inputContent(inputs)
+    ]
+  };
+}
+async function finishResult(broker, context, result) {
+  context.mcpReq.signal.throwIfAborted();
+  const { chatId } = context;
+  const deliveries = broker.deliveries(chatId);
+  const answers = broker.answers(chatId);
+  const content = [
+    ...result.content,
+    ...deliveryContent(deliveries),
+    ...answerContent(answers)
+  ];
+  await broker.acknowledge(deliveries, answers, context.mcpReq.signal);
+  return formatResult({ ...result, content }, chatId);
+}
+function formatResult(result, chatId) {
+  const content = result.content.map((block) => {
+    if (block.type !== "resource_link") return block;
+    const uri = new URL(block.uri);
+    uri.searchParams.set("chatId", chatId);
+    return { ...block, uri: uri.href };
+  });
+  return {
+    ...result,
+    content,
+    structuredContent: {
+      text: content.flatMap((block) => block.type === "text" ? [block.text] : []).join("\n")
+    }
+  };
+}
+function requireChatId(context) {
+  const chatId = context.mcpReq._meta?.["openai/session"];
+  if (typeof chatId !== "string" || !chatId)
+    throw new Error("ChatGPT did not provide openai/session metadata");
+  return chatId;
+}
+
+// src/stdio.ts
+var terminationSignals = process.platform === "win32" ? ["SIGINT", "SIGTERM"] : ["SIGHUP", "SIGINT", "SIGTERM"];
+async function serve() {
+  const broker = new Broker(getDirectory());
+  await broker.start();
+  const output = process.stdout;
+  const transport = new StdioServerTransport(process.stdin, output);
+  let stop;
+  const stopped = new Promise((resolve) => {
+    stop = resolve;
+  });
+  const requestStop = () => stop?.();
+  output.once("error", requestStop);
+  process.stdin.once("end", requestStop);
+  process.stdin.once("close", requestStop);
+  for (const signal of terminationSignals) {
+    process.once(signal, requestStop);
+  }
+  const handle = serveStdio(() => createServer(broker), {
+    transport,
+    onerror(error) {
+      console.error(error);
+      const code = error.code;
+      if (code === "EPIPE" || code === "ERR_STREAM_DESTROYED") requestStop();
+    }
+  });
+  try {
+    await stopped;
+    await handle.close();
+  } finally {
+    await broker.close();
+  }
+}
+export {
+  serve
+};