@zetaloop/chappie 0.5.0 → 1.0.0

package/dist/chunk-5CKVVDZ2.js

@@ -0,0 +1,1042 @@
+import { createRequire } from "node:module"; const require = createRequire(import.meta.url);
+import {
+  IpcClient,
+  source,
+  sourceLabel
+} from "./chunk-EIPDEA3I.js";
+import {
+  Resources,
+  copyFiles,
+  getDirectory,
+  resourceSessionId,
+  transferFiles,
+  transferResult
+} from "./chunk-GWYP7B66.js";
+import {
+  __callDispose,
+  __using
+} from "./chunk-UOFCCHBS.js";
+
+// src/provider.ts
+function createMessage(model, stopReason) {
+  return {
+    role: "assistant",
+    content: [],
+    api: model.api,
+    provider: model.provider,
+    model: model.id,
+    usage: {
+      input: 0,
+      output: 0,
+      cacheRead: 0,
+      cacheWrite: 0,
+      totalTokens: 0,
+      cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 }
+    },
+    stopReason,
+    timestamp: Date.now()
+  };
+}
+var ProviderOutput = class {
+  stream;
+  message;
+  finished;
+  #resolveFinished;
+  #removeAbort;
+  #started = false;
+  #closed = false;
+  constructor(message, stream, signal) {
+    this.stream = stream;
+    this.message = message;
+    const completion = Promise.withResolvers();
+    this.finished = completion.promise;
+    this.#resolveFinished = completion.resolve;
+    if (signal) {
+      const abort = () => this.fail(new Error("Chappie provider request was cancelled"), true);
+      signal.addEventListener("abort", abort, { once: true });
+      this.#removeAbort = () => signal.removeEventListener("abort", abort);
+      if (signal.aborted) abort();
+    }
+  }
+  get closed() {
+    return this.#closed;
+  }
+  begin() {
+    if (this.#started || this.#closed) return;
+    this.#started = true;
+    this.stream.push({ type: "start", partial: this.message });
+  }
+  text(text) {
+    if (this.#closed)
+      throw new Error("Chappie provider response is already complete");
+    this.begin();
+    const contentIndex = this.message.content.length;
+    const block = { type: "text", text: "" };
+    this.message.content.push(block);
+    this.stream.push({
+      type: "text_start",
+      contentIndex,
+      partial: this.message
+    });
+    block.text = text;
+    this.stream.push({
+      type: "text_delta",
+      contentIndex,
+      delta: text,
+      partial: this.message
+    });
+    this.stream.push({
+      type: "text_end",
+      contentIndex,
+      content: text,
+      partial: this.message
+    });
+  }
+  toolCalls(calls) {
+    if (this.#closed)
+      throw new Error("Chappie provider response is already complete");
+    this.begin();
+    for (const call of calls) {
+      const contentIndex = this.message.content.length;
+      const block = { ...call, arguments: {} };
+      this.message.content.push(block);
+      this.stream.push({
+        type: "toolcall_start",
+        contentIndex,
+        partial: this.message
+      });
+      block.arguments = call.arguments;
+      this.stream.push({
+        type: "toolcall_delta",
+        contentIndex,
+        delta: JSON.stringify(call.arguments),
+        partial: this.message
+      });
+      this.stream.push({
+        type: "toolcall_end",
+        contentIndex,
+        toolCall: block,
+        partial: this.message
+      });
+    }
+  }
+  done(reason = "stop") {
+    if (this.#closed) return;
+    this.begin();
+    this.message.stopReason = reason;
+    this.stream.push({ type: "done", reason, message: this.message });
+    this.#finish();
+  }
+  fail(error, aborted = false) {
+    if (this.#closed) return;
+    this.begin();
+    this.message.stopReason = aborted ? "aborted" : "error";
+    this.message.errorMessage = error instanceof Error ? error.message : String(error);
+    this.stream.push({
+      type: "error",
+      reason: aborted ? "aborted" : "error",
+      error: this.message
+    });
+    this.#finish();
+  }
+  #finish() {
+    this.#closed = true;
+    this.#removeAbort?.();
+    this.stream.end();
+    this.#resolveFinished();
+  }
+};
+
+// src/session.ts
+import { randomUUID } from "node:crypto";
+import { addAbortListener } from "node:events";
+import { hostname } from "node:os";
+var Session = class {
+  #host;
+  #config;
+  #syncs = /* @__PURE__ */ new Map();
+  #stores = /* @__PURE__ */ new Map();
+  #ready = /* @__PURE__ */ new Set();
+  #generations = /* @__PURE__ */ new Map();
+  #queue = [];
+  #pendingInputs = /* @__PURE__ */ new Map();
+  #deliveries = /* @__PURE__ */ new Map();
+  #histories = /* @__PURE__ */ new Map();
+  #requests = /* @__PURE__ */ new Map();
+  #operations = /* @__PURE__ */ new Map();
+  #resources = new Resources();
+  #receivedDeliveries = [];
+  #connection;
+  #output;
+  #active;
+  #nextRequestId = 1;
+  #starting = false;
+  #sessionId;
+  #flushing = Promise.resolve();
+  #provider;
+  constructor(host, config = {}) {
+    this.#host = host;
+    this.#config = config;
+  }
+  get localTools() {
+    return Boolean(this.#config.localTools && !this.#host.active());
+  }
+  get active() {
+    return this.#host.active();
+  }
+  deliveries() {
+    return this.#receivedDeliveries.splice(0);
+  }
+  get id() {
+    return this.#host.describe().id;
+  }
+  async sessions(sessionId, signal) {
+    const result = await this.#request(
+      { type: "sessions", ...sessionId ? { sessionId } : {} },
+      signal
+    );
+    if (!("sessions" in result))
+      throw new Error("Broker returned no session list");
+    return { self: this.id, sessions: result.sessions };
+  }
+  async tools(sessionId, names, signal) {
+    const result = await this.#request({ type: "inspect", sessionId }, signal);
+    if (!("inspection" in result))
+      throw new Error("Session returned no tool catalog");
+    return {
+      ...result.inspection,
+      inputs: result.inputs,
+      ...result.globalAgents ? { globalAgents: result.globalAgents } : {},
+      tools: result.inspection.tools.filter(
+        (tool) => !names || names.includes(tool.name)
+      )
+    };
+  }
+  async resource(uri, signal) {
+    signal?.throwIfAborted();
+    const sessionId = resourceSessionId(uri);
+    if (sessionId === this.id) return this.#resources.read(sessionId, uri);
+    const result = await this.#request(
+      { type: "readResource", sessionId, uri },
+      signal
+    );
+    if (!("resource" in result))
+      throw new Error("Session returned no resource");
+    return result.resource;
+  }
+  async history(range, sessionId, signal) {
+    const self = this.#host.describe();
+    if (!sessionId || sessionId === self.id) {
+      const history = await this.#host.history(range);
+      this.#publish(this.#resources.rememberImages(self.id, history.content));
+      return history;
+    }
+    const result = await this.#request(
+      {
+        type: "history",
+        sessionId,
+        range,
+        ...source(self.id, randomUUID(), self.name ?? self.agent)
+      },
+      signal
+    );
+    if (!("history" in result)) throw new Error("Session returned no history");
+    return result.history;
+  }
+  async call(sessionId, calls, signal) {
+    const self = this.#host.describe();
+    const result = await this.#request(
+      {
+        type: "call",
+        sessionId,
+        calls: calls.map((call) => ({
+          ...call,
+          type: "toolCall",
+          id: `chappie-${randomUUID()}`
+        })),
+        ...source(self.id, randomUUID(), self.name ?? self.agent)
+      },
+      signal
+    );
+    if (!("toolResults" in result))
+      throw new Error("Session returned no tool results");
+    return { sessionId, ...result };
+  }
+  async chat(sessionId, text, replyTo, signal) {
+    const self = this.#host.describe();
+    const result = await this.#request(
+      {
+        type: "chat",
+        sessionId,
+        text,
+        ...replyTo ? { replyTo } : {},
+        ...source(self.id, randomUUID(), self.name ?? self.agent)
+      },
+      signal
+    );
+    if (!("message" in result) && !("cancelled" in result))
+      throw new Error("Session returned no assistant message");
+    return { sessionId, ...result };
+  }
+  async ready(signal) {
+    var _stack = [];
+    try {
+      signal.throwIfAborted();
+      if (this.#generations.size || this.#output && !this.#output.closed)
+        return;
+      const completion = Promise.withResolvers();
+      const _abort = __using(_stack, addAbortListener(
+        signal,
+        () => completion.reject(signal.reason)
+      ));
+      this.#ready.add(completion);
+      try {
+        this.#wake();
+        await completion.promise;
+      } finally {
+        this.#ready.delete(completion);
+      }
+    } catch (_) {
+      var _error = _, _hasError = true;
+    } finally {
+      __callDispose(_stack, _error, _hasError);
+    }
+  }
+  async settled(error) {
+    const starting = this.#starting;
+    this.#starting = false;
+    const reason = error instanceof Error ? error.message : error === void 0 ? "Session ended before the request completed" : String(error);
+    if (error !== void 0 || starting)
+      this.#rejectReady(error ?? new Error(reason));
+    const active = this.#active;
+    if (active && !active.completed) {
+      active.completed = true;
+      active.error = reason;
+    } else if (!active && starting) {
+      const request = this.#queue.shift();
+      if (request) await this.#sendError(request.id, reason);
+    }
+    this.#collectInputs();
+    this.historyChanged();
+    await this.#completeActive();
+    this.#dispatch();
+  }
+  #notify(message, type = "info", activity = {}) {
+    this.#host.notify?.(message, type, activity);
+    if (activity.event !== "history") this.historyChanged();
+  }
+  async start(output) {
+    const connection = this.#connection;
+    if (!this.#host.active() || !connection) {
+      throw new Error("Chappie is not active for this session");
+    }
+    if (this.#output && !this.#output.closed) {
+      throw new Error("Chappie already has an active provider request");
+    }
+    this.#starting = false;
+    this.#output = output;
+    for (const pending of this.#ready) pending.resolve();
+    try {
+      await connection.connect();
+      if (output.closed) return;
+      this.#collectInputs();
+      this.historyChanged();
+      await this.#completeActive();
+      await this.#sync();
+      if (output.closed) return;
+      output.begin();
+      this.#dispatch();
+      await output.finished;
+    } finally {
+      if (this.#output === output) this.#output = void 0;
+      void this.#sync().catch(() => {
+      });
+    }
+  }
+  async generate(output, request) {
+    const connection = this.#connection;
+    if (!this.#host.active() || !connection)
+      throw new Error("Chappie is not active for this session");
+    if (output.closed) return;
+    const id = randomUUID();
+    this.#starting = false;
+    this.#generations.set(id, { output, request });
+    for (const pending of this.#ready) pending.resolve();
+    try {
+      await connection.connect();
+      if (output.closed) return;
+      this.historyChanged();
+      await this.#completeActive();
+      output.begin();
+      await this.#sync();
+      for (const queued of this.#queue.splice(0))
+        await this.#cancelPending(queued);
+      await output.finished;
+    } finally {
+      this.#generations.delete(id);
+      void this.#sync().catch(() => {
+      });
+      this.#dispatch();
+    }
+  }
+  async transfer(args, signal, update) {
+    const context = {
+      ...this.#host.describe(),
+      resources: this.#resources,
+      ...this.#host.mutate ? { mutate: this.#host.mutate } : {}
+    };
+    if ([args.files, args.from, args.to].filter(Boolean).length > 1)
+      throw new Error("Supply one of files, from, or to");
+    if (args.from) {
+      const result2 = await this.#request(
+        {
+          type: "export",
+          sessionId: args.from.sessionId,
+          paths: args.from.paths
+        },
+        signal
+      );
+      if (!("transfer" in result2))
+        throw new Error("Session returned no resources");
+      const copying = signal ?? new AbortController().signal;
+      const files = await copyFiles(
+        args.paths,
+        result2.transfer.resources,
+        context.cwd,
+        args.overwrite === true,
+        (resource) => this.#readChunks(resource, copying),
+        copying,
+        context.mutate
+      );
+      return transferResult({
+        device: hostname(),
+        files,
+        resources: [],
+        from: {
+          sessionId: args.from.sessionId,
+          device: result2.transfer.device
+        }
+      });
+    }
+    if (!args.to) {
+      const result2 = await transferFiles(args, context, signal, update);
+      this.#publish(result2.details.resources);
+      return result2;
+    }
+    if (args.paths.length !== args.to.paths.length)
+      throw new Error("Source and destination counts must match");
+    const { sessions } = await this.sessions(args.to.sessionId, signal);
+    const destination = sessions[0];
+    if (!destination) throw new Error("Destination session is unavailable");
+    const exported = await transferFiles(
+      { paths: args.paths },
+      context,
+      signal
+    );
+    this.#publish(exported.details.resources);
+    update?.({
+      ...exported.details,
+      to: {
+        sessionId: args.to.sessionId,
+        device: destination.device
+      }
+    });
+    const result = await this.#request(
+      {
+        type: "copy",
+        sessionId: args.to.sessionId,
+        paths: args.to.paths,
+        resources: exported.details.resources,
+        ...args.overwrite !== void 0 ? { overwrite: args.overwrite } : {}
+      },
+      signal
+    );
+    if (!("transfer" in result))
+      throw new Error("Session returned no transfer result");
+    return transferResult({ ...result.transfer, device: hostname() });
+  }
+  close() {
+    const sessionId = this.#sessionId;
+    if (sessionId && this.#connection?.connected) {
+      void this.#connection.send({ type: "unregister", sessionId }).catch(() => {
+      });
+    }
+    this.#output?.fail(new Error("Chappie session ended"), true);
+    for (const { output } of this.#generations.values())
+      output.fail(new Error("Chappie session ended"), true);
+    this.#generations.clear();
+    this.#output = void 0;
+    this.#active = void 0;
+    this.#queue.length = 0;
+    this.#starting = false;
+    this.#connection?.close();
+    this.#connection = void 0;
+    this.resetInputs();
+    this.#cancelRequests(new Error("Chappie session ended"));
+    this.#rejectReady(new Error("Chappie session ended"));
+    this.#rejectSyncs(new Error("Chappie session ended"));
+    this.#rejectStores(new Error("Chappie session ended"));
+    for (const id of this.#histories.keys()) this.#finishHistory(id);
+  }
+  update() {
+    const active = this.#host.active();
+    const id = this.#host.describe().id;
+    const changed = this.#sessionId !== id || this.#provider !== active;
+    if (changed) {
+      if (this.#connection) this.close();
+      else this.resetInputs();
+    }
+    this.#provider = active;
+    if (!active && !this.#config.localTools) return changed;
+    if (!this.#connection) {
+      this.#connection = new IpcClient(getDirectory(), this.#config.connect, {
+        onOpen: async () => {
+          this.#publish(this.#resources.list());
+          await this.#sync();
+          await this.#flushDeliveries();
+        },
+        onMessage: (message) => this.#receive(message),
+        onClose: (error) => {
+          this.#cancelRequests(error);
+          this.#rejectReady(error);
+          for (const id2 of this.#histories.keys()) this.#finishHistory(id2);
+          this.#rejectSyncs(error);
+          this.#rejectStores(error);
+          if (this.#output && !this.#output.closed) this.#output.fail(error);
+          else this.#notify(error.message, "error");
+          for (const { output } of this.#generations.values())
+            output.fail(error);
+          this.#active = void 0;
+          this.#queue.length = 0;
+          this.#starting = false;
+        }
+      });
+      this.#connection.start();
+    } else {
+      void this.#sync().catch(() => {
+      });
+    }
+    return changed;
+  }
+  #description(sessionId = this.#sessionId) {
+    if (sessionId !== this.#sessionId)
+      throw new Error("The requested session is no longer active");
+    return {
+      ...this.#host.describe(),
+      status: this.#generations.size ? "generating" : this.#active ? "executing" : this.#output && !this.#output.closed ? "ready" : "idle"
+    };
+  }
+  async #sync() {
+    const connection = this.#connection;
+    if (!connection?.connected || !this.#host.active()) return;
+    const id = this.#nextRequestId++;
+    const completion = Promise.withResolvers();
+    this.#syncs.set(id, completion);
+    try {
+      await connection.send({ type: "sync", id, session: this.#description() });
+      await completion.promise;
+    } finally {
+      this.#syncs.delete(id);
+    }
+  }
+  async #receive(message) {
+    switch (message.type) {
+      case "response": {
+        const pending = this.#requests.get(message.id);
+        if (!pending) break;
+        if ("error" in message) pending.reject(new Error(message.error));
+        else {
+          const { type: _type, id: _id, deliveries, ...result } = message;
+          this.#receivedDeliveries.push(...deliveries ?? []);
+          pending.resolve(result);
+        }
+        break;
+      }
+      case "synced":
+        this.#syncs.get(message.id)?.resolve();
+        break;
+      case "stored":
+        this.#stores.get(message.id)?.resolve();
+        break;
+      case "notice":
+        if (message.sessionId === this.#sessionId) {
+          this.#notify(message.message, "info", message.activity);
+        }
+        break;
+      case "inspect":
+        await this.#reply(message.id, async (signal) => {
+          const { globalAgents, ...environment } = await this.#host.inspect(signal);
+          return {
+            type: "result",
+            id: message.id,
+            inspection: {
+              session: this.#description(message.sessionId),
+              ...environment
+            },
+            inputs: this.#inputs(),
+            ...globalAgents ? { globalAgents } : {}
+          };
+        });
+        break;
+      case "inputs":
+        await this.#reply(message.id, () => {
+          this.#description(message.sessionId);
+          return {
+            type: "result",
+            id: message.id,
+            inputs: this.#inputs()
+          };
+        });
+        break;
+      case "history":
+        await this.#readHistory(message);
+        break;
+      case "ackInputs":
+        if (message.sessionId === this.#sessionId) {
+          for (const id of message.ids) this.#pendingInputs.delete(id);
+        }
+        break;
+      case "readResource":
+        await this.#reply(message.id, async () => ({
+          type: "result",
+          id: message.id,
+          resource: await this.#resources.read(
+            message.sessionId,
+            message.uri,
+            message.offset
+          )
+        }));
+        break;
+      case "export":
+        await this.#reply(message.id, async (signal) => {
+          this.#description(message.sessionId);
+          const result = await this.transfer({ paths: message.paths }, signal);
+          return { type: "result", id: message.id, transfer: result.details };
+        });
+        break;
+      case "copy": {
+        await this.#reply(message.id, async (signal) => {
+          const context = this.#description(message.sessionId);
+          const files = await copyFiles(
+            message.paths,
+            message.resources,
+            context.cwd,
+            message.overwrite === true,
+            (resource) => this.#readChunks(resource, signal),
+            signal,
+            this.#host.mutate
+          );
+          return {
+            type: "result",
+            id: message.id,
+            transfer: {
+              device: hostname(),
+              files,
+              resources: [],
+              to: { sessionId: message.sessionId, device: hostname() }
+            }
+          };
+        });
+        break;
+      }
+      case "cancel": {
+        const operation = this.#operations.get(message.id);
+        if (operation) {
+          operation.abort(new Error(message.reason));
+          break;
+        }
+        if (this.#histories.has(message.id)) {
+          this.#finishHistory(message.id);
+          break;
+        }
+        const queued = this.#queue.findIndex(
+          (request2) => request2.id === message.id
+        );
+        const request = this.#queue[queued] ?? (this.#active?.request.id === message.id ? this.#active.request : void 0);
+        if (!request) break;
+        const name = request.type === "call" ? [...new Set(request.calls.map((call) => call.name))].join(", ") : "chat";
+        this.#notify(
+          `${name} cancelled for ${sourceLabel(request)}: ${message.reason}`,
+          "warning",
+          {
+            event: "cancelled",
+            ...source(request.clientId, request.requestId, request.label)
+          }
+        );
+        if (queued !== -1) {
+          this.#queue.splice(queued, 1);
+          break;
+        }
+        const active = this.#active;
+        if (!active) break;
+        active.cancelled = message.reason;
+        if (active.completed) await this.#completeActive();
+        else await this.#host.abort();
+        break;
+      }
+      case "chat":
+      case "call":
+        if (message.sessionId !== this.#sessionId) {
+          await this.#sendError(
+            message.id,
+            "The requested session is no longer active"
+          );
+          break;
+        }
+        if (message.type === "chat" && message.replyTo) {
+          const generation = this.#generations.get(message.replyTo);
+          if (!generation || generation.output.closed) {
+            await this.#sendError(message.id, "The model request has ended");
+            break;
+          }
+          const output = generation.output;
+          output.message.chappie = source(
+            message.clientId,
+            message.requestId,
+            message.label
+          );
+          output.text(message.text);
+          output.done();
+          this.#generations.delete(message.replyTo);
+          await this.#connection?.send({
+            type: "result",
+            id: message.id,
+            cwd: this.#host.describe().cwd,
+            message: output.message,
+            inputs: this.#inputs()
+          });
+          break;
+        }
+        if (this.#generations.size) {
+          await this.#cancelPending(message);
+          break;
+        }
+        this.#queue.push(message);
+        this.#dispatch();
+        break;
+    }
+  }
+  async #cancelPending(request) {
+    await this.#connection?.send({
+      type: "result",
+      id: request.id,
+      cwd: this.#host.describe().cwd,
+      cancelled: request.type === "call" ? "The requested tools were not executed. A model request is awaiting a reply." : "A model request is awaiting a reply. Set replyTo to its request ID.",
+      toolResults: [],
+      inputs: this.#inputs()
+    });
+  }
+  #publish(resources) {
+    if (!resources.length) return;
+    if (this.#connection?.connected) {
+      void this.#connection.send({ type: "resources", resources }).catch(() => {
+      });
+    }
+  }
+  async #request(request, signal) {
+    signal?.throwIfAborted();
+    const connection = this.#connection;
+    if (!connection?.connected) throw new Error("Chappie is not connected");
+    const id = this.#nextRequestId++;
+    const completion = Promise.withResolvers();
+    const onAbort = () => {
+      completion.reject(signal?.reason);
+      void connection.send({ type: "cancelRequest", id }).catch(() => {
+      });
+    };
+    this.#requests.set(id, completion);
+    signal?.addEventListener("abort", onAbort, { once: true });
+    void connection.send({ type: "request", id, clientId: this.id, request }).catch(completion.reject);
+    try {
+      return await completion.promise;
+    } finally {
+      this.#requests.delete(id);
+      signal?.removeEventListener("abort", onAbort);
+    }
+  }
+  async *#readChunks(resource, signal) {
+    for (let offset = 0; offset < resource.size; ) {
+      const result = await this.#request(
+        {
+          type: "readResource",
+          sessionId: resourceSessionId(resource.uri),
+          uri: resource.uri,
+          offset
+        },
+        signal
+      );
+      if (!("resource" in result))
+        throw new Error("Session returned no resource");
+      const data = Buffer.from(result.resource.blob, "base64");
+      if (data.length === 0)
+        throw new Error(
+          `Source ended before ${resource.size} bytes: ${resource.name}`
+        );
+      yield data;
+      offset += data.length;
+    }
+  }
+  #cancelRequests(error) {
+    for (const pending of this.#requests.values()) pending.reject(error);
+    this.#requests.clear();
+    for (const controller of this.#operations.values()) controller.abort(error);
+    this.#operations.clear();
+  }
+  async #readHistory(request, wait = request.range.wait) {
+    try {
+      const context = this.#host.describe();
+      if (context.id !== request.sessionId)
+        throw new Error("The requested session is no longer active");
+      const history = await this.history(request.range);
+      if (wait && !request.range.before && history.count === 0) {
+        if (!this.#histories.has(request.id)) {
+          this.#histories.set(request.id, {
+            request,
+            timeout: setTimeout(() => {
+              void this.#readHistory(request, false).catch(() => {
+              });
+            }, 3e4)
+          });
+        }
+        return;
+      }
+      this.#finishHistory(request.id);
+      if (!request.range.observer) {
+        this.#notify(
+          `${sourceLabel(request)} read history: ${history.count} entries`,
+          "info",
+          {
+            event: "history",
+            ...source(request.clientId, request.requestId, request.label)
+          }
+        );
+      }
+      await this.#connection?.send({
+        type: "result",
+        id: request.id,
+        cwd: context.cwd,
+        history
+      });
+    } catch (error) {
+      this.#finishHistory(request.id);
+      await this.#sendError(
+        request.id,
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  }
+  historyChanged() {
+    for (const { request } of this.#histories.values()) {
+      void this.#readHistory(request).catch(() => {
+      });
+    }
+  }
+  #finishHistory(id) {
+    const pending = this.#histories.get(id);
+    if (!pending) return;
+    clearTimeout(pending.timeout);
+    this.#histories.delete(id);
+  }
+  #dispatch() {
+    if (this.#active || this.#generations.size) return;
+    const output = this.#output;
+    if (!output || output.closed) {
+      this.#wake();
+      return;
+    }
+    const request = this.#queue.shift();
+    if (!request) return;
+    output.message.chappie = source(
+      request.clientId,
+      request.requestId,
+      request.label
+    );
+    this.#active = {
+      request,
+      session: this.#description(),
+      message: output.message,
+      completed: false,
+      cancelled: void 0,
+      toolResults: []
+    };
+    void this.#sync().catch(() => {
+    });
+    if (request.type === "chat") {
+      output.text(request.text);
+      output.done();
+    } else {
+      output.toolCalls(request.calls);
+      output.done("toolUse");
+    }
+  }
+  #wake() {
+    if (this.#starting || this.#generations.size || this.#output || this.#active || this.#queue.length === 0 && this.#ready.size === 0 || !this.#host.isIdle())
+      return;
+    this.#starting = true;
+    void Promise.resolve().then(() => this.#host.wake()).catch((error) => {
+      this.#starting = false;
+      this.#rejectReady(error);
+      const request = this.#queue.shift();
+      if (request)
+        return this.#sendError(
+          request.id,
+          error instanceof Error ? error.message : String(error)
+        );
+    });
+  }
+  complete(message, toolResults, error) {
+    this.historyChanged();
+    const active = this.#active;
+    const completed = message;
+    const origin = completed?.chappie;
+    const failure = error ?? completed?.errorMessage;
+    if (!active || failure === void 0 && message !== active.message && (!origin || origin.clientId !== active.request.clientId || origin.requestId !== active.request.requestId))
+      return;
+    const sessionId = active.session.id;
+    for (const result of toolResults)
+      this.#publish(this.#resources.rememberImages(sessionId, result.content));
+    if (failure !== void 0) active.error = failure;
+    active.toolResults = toolResults;
+    if (active.request.type === "call") {
+      const results = new Map(
+        toolResults.map((result) => [result.toolCallId, result])
+      );
+      active.toolResults = active.request.calls.flatMap(
+        (call) => results.get(call.id) ?? []
+      );
+      const missing = active.request.calls.flatMap(
+        (call, index) => results.has(call.id) ? [] : [`${index + 1} (${call.name})`]
+      );
+      if (missing.length)
+        active.error ??= `No results for calls ${missing.join(", ")}`;
+    }
+    active.completed = true;
+  }
+  async #completeActive() {
+    const active = this.#active;
+    if (!active?.completed) return;
+    this.#collectInputs();
+    const inputs = this.#inputs();
+    if (active.cancelled !== void 0) {
+      const delivery = {
+        id: randomUUID(),
+        ...source(
+          active.request.clientId,
+          active.request.requestId,
+          active.request.label
+        ),
+        sessionId: active.session.id,
+        cwd: active.session.cwd,
+        toolResults: active.toolResults,
+        error: active.cancelled
+      };
+      this.#deliveries.set(delivery.id, delivery);
+      void this.#flushDeliveries().catch(() => {
+      });
+    } else if (active.error !== void 0) {
+      await this.#sendError(active.request.id, active.error);
+    } else {
+      await this.#connection?.send({
+        type: "result",
+        id: active.request.id,
+        cwd: active.session.cwd,
+        message: active.message,
+        inputs,
+        ...active.request.type === "call" ? { toolResults: active.toolResults } : {}
+      });
+    }
+    this.#active = void 0;
+    void this.#sync().catch(() => {
+    });
+  }
+  resetInputs() {
+    this.#sessionId = this.#host.describe().id;
+    this.#pendingInputs.clear();
+    this.#host.resetInputs();
+  }
+  #collectInputs() {
+    if (!this.#host.active()) return;
+    for (const input of this.#host.inputs()) {
+      if ("message" in input && typeof input.message.content !== "string")
+        this.#publish(
+          this.#resources.rememberImages(
+            input.sessionId,
+            input.message.content
+          )
+        );
+      this.#pendingInputs.set(input.id, input);
+    }
+  }
+  #inputs() {
+    this.#collectInputs();
+    const generation = this.#generations.entries().next().value;
+    return [
+      ...generation ? [
+        {
+          id: generation[0],
+          sessionId: this.id,
+          request: generation[1].request
+        }
+      ] : [],
+      ...this.#pendingInputs.values()
+    ];
+  }
+  async #flushDeliveries() {
+    const flushed = this.#flushing.then(async () => {
+      const connection = this.#connection;
+      if (!connection?.connected) return;
+      for (const delivery of this.#deliveries.values()) {
+        const completion = Promise.withResolvers();
+        this.#stores.set(delivery.id, completion);
+        try {
+          await connection.send({ type: "delivery", delivery });
+          await completion.promise;
+          this.#deliveries.delete(delivery.id);
+          this.#notify(`Result saved for ${sourceLabel(delivery)}`, "info", {
+            event: "result_saved",
+            ...source(delivery.clientId, delivery.requestId, delivery.label)
+          });
+        } finally {
+          this.#stores.delete(delivery.id);
+        }
+      }
+    });
+    this.#flushing = flushed.catch(() => {
+    });
+    return flushed;
+  }
+  async #reply(id, response) {
+    const controller = new AbortController();
+    this.#operations.set(id, controller);
+    try {
+      await this.#connection?.send(await response(controller.signal));
+    } catch (error) {
+      await this.#sendError(
+        id,
+        error instanceof Error ? error.message : String(error)
+      );
+    } finally {
+      this.#operations.delete(id);
+    }
+  }
+  #rejectReady(error) {
+    for (const pending of this.#ready) pending.reject(error);
+  }
+  async #sendError(id, error) {
+    await this.#connection?.send({ type: "result", id, error });
+  }
+  #rejectSyncs(error) {
+    for (const sync of this.#syncs.values()) sync.reject(error);
+    this.#syncs.clear();
+  }
+  #rejectStores(error) {
+    for (const store of this.#stores.values()) store.reject(error);
+    this.#stores.clear();
+  }
+};
+
+export {
+  createMessage,
+  ProviderOutput,
+  Session
+};