zooid 0.7.4 → 0.8.0

package/dist/{chunk-OKGNOROJ.js → chunk-R6EDLH23.js}

@@ -6979,6 +6979,7 @@ var DockerAcpRuntime = class {
     this.opts = opts;
     this.engine = opts.engine ?? "docker";
   }
+  opts;
   engine;
   buildArgv(spec) {
     const image = spec.image ?? this.opts.defaultImage;
@@ -23115,6 +23116,7 @@ var AgentProcess = class extends EventEmitter {
     super();
     this.options = options;
   }
+  options;
   child = null;
   start() {
     if (this.child) return;
@@ -23182,6 +23184,7 @@ var JsonFileSessionStore = class {
     this.opts = opts;
     this.path = join(opts.dir, "sessions.json");
   }
+  opts;
   mem = /* @__PURE__ */ new Map();
   path;
   writeChain = Promise.resolve();
@@ -23498,6 +23501,7 @@ var AcpClient = class {
     this.options = options;
     this.turns = options.onTap ? new TurnTracker({ agentId: options.agent.id, onTap: options.onTap }) : null;
   }
+  options;
   process = null;
   runtimeChild = null;
   connection = null;
@@ -25047,6 +25051,7 @@ var MatrixContextProvider = class {
   constructor(opts) {
     this.opts = opts;
   }
+  opts;
   async getRoomHistory(channelId, hopts) {
     const { chunk, end } = await this.opts.client.fetchRoomMessages({
       roomId: channelId,
@@ -25134,14 +25139,29 @@ var MatrixContextProvider = class {
   }
   toMessage(ev) {
     if (ev.type !== "m.room.message") return null;
-    if (ev.content?.msgtype !== "m.text" || typeof ev.content.body !== "string") return null;
+    const msgtype = ev.content?.msgtype;
+    const body = ev.content?.body;
     const agent = this.opts.agentBots.get(ev.sender);
-    const relatesTo = ev.content["m.relates_to"];
+    const relatesTo = ev.content?.["m.relates_to"];
     const threadId = relatesTo?.rel_type === "m.thread" && relatesTo.event_id ? relatesTo.event_id : void 0;
+    if (msgtype === "m.image" || msgtype === "m.file" || msgtype === "m.video" || msgtype === "m.audio") {
+      const kind = msgtype.slice(2);
+      const name = typeof body === "string" && body ? body : "untitled";
+      return {
+        id: ev.event_id,
+        sender: ev.sender,
+        text: `[${kind}: ${name}]`,
+        timestamp: new Date(ev.origin_server_ts).toISOString(),
+        is_agent: agent !== void 0,
+        ...agent !== void 0 ? { agent_name: agent } : {},
+        ...threadId !== void 0 ? { thread_id: threadId } : {}
+      };
+    }
+    if (msgtype !== "m.text" || typeof body !== "string") return null;
     return {
       id: ev.event_id,
       sender: ev.sender,
-      text: ev.content.body,
+      text: body,
       timestamp: new Date(ev.origin_server_ts).toISOString(),
       is_agent: agent !== void 0,
       ...agent !== void 0 ? { agent_name: agent } : {},
@@ -25215,6 +25235,10 @@ function stripMention(body, userId) {
 }
 
 // ../transport-matrix/src/router.ts
+var MEDIA_MSGTYPES = /* @__PURE__ */ new Set(["m.image", "m.file", "m.video", "m.audio"]);
+function isMediaMsgtype(t) {
+  return t !== void 0 && MEDIA_MSGTYPES.has(t);
+}
 function inboundThreadRoot(event) {
   const r = event.content?.["m.relates_to"];
   return r?.rel_type === "m.thread" && r.event_id ? r.event_id : void 0;
@@ -25222,6 +25246,7 @@ function inboundThreadRoot(event) {
 function route(event, agents, threadStates) {
   if (event.type !== "m.room.message") return [];
   if (!event.content?.msgtype) return [];
+  if (isMediaMsgtype(event.content.msgtype)) return [];
   const mentions = new Set(extractMentions(event));
   const matches = [];
   const threadRoot = inboundThreadRoot(event);
@@ -25260,10 +25285,12 @@ async function ensureWorkforceSpace(opts) {
     name: display,
     preset: opts.preset,
     creation_content: { type: "m.space" },
-    // A workspace is joined by invitation, not self-service. Pin the space's
-    // join rule to invite regardless of preset so it can't be walked into
-    // (which would otherwise satisfy every restricted child room's allow).
-    initial_state: [{ type: "m.room.join_rules", state_key: "", content: { join_rule: "invite" } }]
+    // Pin the join rule regardless of preset. Defaults to invite so the space
+    // can't be walked into (which would otherwise satisfy every restricted
+    // child room's allow); `zooid dev` opts into `public` for local-only use.
+    initial_state: [
+      { type: "m.room.join_rules", state_key: "", content: { join_rule: opts.joinRule ?? "invite" } }
+    ]
   };
   if (opts.admins && opts.admins.length > 0) {
     body.invite = opts.admins;
@@ -25314,6 +25341,8 @@ var BotPool = class {
     this.client = client;
     this.agents = agents;
   }
+  client;
+  agents;
   async bootstrap(opts = {}) {
     const aliasToId = /* @__PURE__ */ new Map();
     const attachedToSpace = /* @__PURE__ */ new Set();
@@ -25576,8 +25605,180 @@ function toMatrixHtml(markdown) {
   });
 }
 
+// ../transport-matrix/src/pending-media.ts
+var MAX_MEDIA_PER_TURN = 8;
+var PendingMediaStore = class {
+  queues = /* @__PURE__ */ new Map();
+  key(roomId, threadKey) {
+    return `${roomId} ${threadKey ?? "main"}`;
+  }
+  add(roomId, threadKey, item) {
+    const k = this.key(roomId, threadKey);
+    const q = this.queues.get(k) ?? [];
+    q.push(item);
+    while (q.length > MAX_MEDIA_PER_TURN) q.shift();
+    this.queues.set(k, q);
+  }
+  drain(roomId, threadKey, sender) {
+    const k = this.key(roomId, threadKey);
+    const q = this.queues.get(k) ?? [];
+    const mine = q.filter((i) => i.sender === sender);
+    const rest = q.filter((i) => i.sender !== sender);
+    if (rest.length) this.queues.set(k, rest);
+    else this.queues.delete(k);
+    return mine;
+  }
+};
+
+// ../transport-matrix/src/media-client.ts
+var MAX_INLINE_IMAGE_BYTES = 524288;
+var INLINE_IMAGE_MIMES = ["image/png", "image/jpeg", "image/gif", "image/webp"];
+var MAX_DOWNLOAD_BYTES = 33554432;
+function parseMxcUri(uri) {
+  const m = /^mxc:\/\/([^/]+)\/(.+)$/.exec(uri);
+  return m ? { serverName: m[1], mediaId: m[2] } : null;
+}
+var MediaClient = class {
+  homeserver;
+  asToken;
+  fetch;
+  constructor(opts) {
+    this.homeserver = opts.homeserver.replace(/\/$/, "");
+    this.asToken = opts.asToken;
+    this.fetch = opts.fetch ?? globalThis.fetch;
+  }
+  async download(input) {
+    const parsed = parseMxcUri(input.mxcUri);
+    if (!parsed) throw new Error(`not an mxc uri: ${input.mxcUri}`);
+    const url2 = `${this.homeserver}/_matrix/client/v1/media/download/${encodeURIComponent(parsed.serverName)}/${encodeURIComponent(parsed.mediaId)}?user_id=${encodeURIComponent(input.asUserId)}`;
+    const r = await this.fetch(url2, {
+      headers: { Authorization: `Bearer ${this.asToken}` }
+    });
+    if (!r.ok) throw new Error(`media download failed: ${r.status}`);
+    const buf = new Uint8Array(await r.arrayBuffer());
+    const max = input.maxBytes ?? MAX_DOWNLOAD_BYTES;
+    if (buf.byteLength > max) {
+      throw new Error(`media too large: ${buf.byteLength} > ${max}`);
+    }
+    return { data: buf, contentType: r.headers.get("content-type") ?? "application/octet-stream" };
+  }
+  async upload(input) {
+    const params = new URLSearchParams();
+    if (input.filename) params.set("filename", input.filename);
+    params.set("user_id", input.asUserId);
+    const r = await this.fetch(`${this.homeserver}/_matrix/media/v3/upload?${params}`, {
+      method: "POST",
+      headers: { Authorization: `Bearer ${this.asToken}`, "Content-Type": input.contentType },
+      body: input.data
+    });
+    if (!r.ok) throw new Error(`media upload failed: ${r.status}`);
+    return await r.json();
+  }
+};
+
+// ../transport-matrix/src/attachments.ts
+import { mkdirSync as mkdirSync2, writeFileSync } from "fs";
+import { join as join4 } from "path";
+import { posix } from "path";
+function sanitize(s, fallback) {
+  const cleaned = s.replace(/[^A-Za-z0-9._-]/g, "").replace(/^\.+/, "");
+  return cleaned || fallback;
+}
+function writeAttachment(input) {
+  const dir = sanitize(input.eventId, "event");
+  const name = sanitize(input.filename, "file");
+  const hostDir = join4(input.workspaceDir, ".zooid", "attachments", dir);
+  mkdirSync2(hostDir, { recursive: true });
+  const hostPath = join4(hostDir, name);
+  writeFileSync(hostPath, input.data);
+  const agentPath = posix.join(input.agentWorkspacePath, ".zooid", "attachments", dir, name);
+  return { hostPath, agentPath };
+}
+
 // ../transport-matrix/src/transport.ts
 var STARTUP_GRACE_MS = 5e3;
+async function buildMediaBlocks(items, opts) {
+  const blocks = [];
+  const pathLines = [];
+  if (!opts.media || items.length === 0) return { blocks, pathLines };
+  for (const item of items) {
+    try {
+      const isInlineCandidate = item.msgtype === "m.image" && INLINE_IMAGE_MIMES.includes(item.info?.mimetype ?? "") && (item.info?.size === void 0 || item.info.size <= MAX_INLINE_IMAGE_BYTES);
+      if (isInlineCandidate) {
+        const { data, contentType } = await opts.media.download({
+          mxcUri: item.url,
+          asUserId: opts.agent.userId
+        });
+        if (data.byteLength <= MAX_INLINE_IMAGE_BYTES) {
+          blocks.push({
+            type: "image",
+            data: Buffer.from(data).toString("base64"),
+            mimeType: contentType
+          });
+          continue;
+        }
+        if (opts.agent.workspaceDir) {
+          const paths = opts.writeAttachmentFn({
+            workspaceDir: opts.agent.workspaceDir,
+            agentWorkspacePath: opts.agent.agentWorkspacePath ?? opts.agent.workspaceDir,
+            eventId: item.eventId,
+            filename: item.filename ?? item.body,
+            data
+          });
+          blocks.push({
+            type: "resource_link",
+            uri: `file://${paths.agentPath}`,
+            name: item.filename ?? item.body
+          });
+          pathLines.push(`Attached file: ${paths.agentPath}`);
+        }
+      } else {
+        if (!opts.agent.workspaceDir) continue;
+        const { data } = await opts.media.download({
+          mxcUri: item.url,
+          asUserId: opts.agent.userId
+        });
+        const paths = opts.writeAttachmentFn({
+          workspaceDir: opts.agent.workspaceDir,
+          agentWorkspacePath: opts.agent.agentWorkspacePath ?? opts.agent.workspaceDir,
+          eventId: item.eventId,
+          filename: item.filename ?? item.body,
+          data
+        });
+        blocks.push({
+          type: "resource_link",
+          uri: `file://${paths.agentPath}`,
+          name: item.filename ?? item.body,
+          mimeType: item.info?.mimetype,
+          size: item.info?.size
+        });
+        pathLines.push(`Attached file: ${paths.agentPath}`);
+      }
+    } catch (err) {
+      opts.onError(item, err);
+    }
+  }
+  return { blocks, pathLines };
+}
+async function sendMediaError(ctx, _err, message, client) {
+  await client.sendCustomEvent({
+    roomId: ctx.roomId,
+    asUserId: ctx.agent.userId,
+    eventType: "eco.zoon.error",
+    content: toErrorBody(
+      {
+        kind: "error",
+        agentId: ctx.agent.name,
+        sessionId: null,
+        turnId: null,
+        code: "media_failed",
+        message: message.slice(0, 250),
+        transient: false
+      },
+      ctx.threadRoot
+    )
+  }).catch((e) => console.warn(`[matrix:${ctx.agent.name}] eco.zoon.error send failed:`, e));
+}
 var SEEN_EVENT_CAP = 5e3;
 var DRAIN_QUIET_MS = 300;
 var DRAIN_MAX_MS = 3e4;
@@ -25590,6 +25791,9 @@ function createMatrixTransport(opts) {
   const { agents, approvals, client, bindings, hsToken, adminUserId } = opts;
   const drainQuietMs = opts.drainQuietMs ?? DRAIN_QUIET_MS;
   const drainMaxMs = opts.drainMaxMs ?? DRAIN_MAX_MS;
+  const mediaClient = opts.media;
+  const writeAttachmentFn = opts.writeAttachmentFn ?? writeAttachment;
+  const pendingMedia = new PendingMediaStore();
   const pool = new BotPool(client, bindings);
   const sessions = /* @__PURE__ */ new Map();
   const buffers = /* @__PURE__ */ new Map();
@@ -25615,6 +25819,29 @@ function createMatrixTransport(opts) {
         buffers.set(event.sessionId, current + prefix + block.text);
         if (event.messageId !== void 0)
           bufferMessageIds.set(event.sessionId, event.messageId);
+      } else if (block.type === "image" && typeof block.data === "string" && typeof block.mimeType === "string" && mediaClient) {
+        const ctx2 = sessions.get(event.sessionId);
+        if (ctx2) {
+          const bytes = Buffer.from(block.data, "base64");
+          const ext = (block.mimeType.split("/")[1] ?? "png").replace(/[^a-z0-9]/gi, "");
+          const filename = `image.${ext}`;
+          void mediaClient.upload({ data: bytes, contentType: block.mimeType, filename, asUserId: ctx2.agent.userId }).then(
+            ({ content_uri }) => client.sendMessage({
+              roomId: ctx2.roomId,
+              asUserId: ctx2.agent.userId,
+              threadRoot: ctx2.threadRoot,
+              content: {
+                msgtype: "m.image",
+                body: filename,
+                url: content_uri,
+                info: { mimetype: block.mimeType, size: bytes.length }
+              }
+            })
+          ).catch((err) => {
+            console.warn(`[matrix:${name}] outbound image upload failed:`, err);
+            void sendMediaError(ctx2, err, "agent image upload failed", client);
+          });
+        }
       } else {
         console.warn(`[matrix:${name}] dropped chunk block type=${block.type}`, block);
       }
@@ -25757,6 +25984,18 @@ function createMatrixTransport(opts) {
         continue;
       }
       logInbound(evt);
+      if (evt.type === "m.room.message" && isMediaMsgtype(evt.content?.msgtype) && evt.room_id && evt.event_id && evt.sender && evt.content?.url && !bindings.some((b) => b.userId === evt.sender)) {
+        pendingMedia.add(evt.room_id, inboundThreadRoot2(evt), {
+          eventId: evt.event_id,
+          sender: evt.sender,
+          msgtype: evt.content.msgtype,
+          body: evt.content.body ?? "",
+          filename: evt.content.filename,
+          url: evt.content.url,
+          info: evt.content.info
+        });
+        continue;
+      }
       const promotedRoot = inboundThreadRoot2(evt) ?? evt.event_id;
       const inboundRel = inboundThreadRoot2(evt);
       if (evt.type === "m.room.message" && inboundRel && !threadStates.has(inboundRel) && evt.room_id) {
@@ -25873,10 +26112,30 @@ function createMatrixTransport(opts) {
     try {
       const rawBody = evt.content?.body ?? "";
       const promptText = stripMention(rawBody, agent.userId);
+      const pendingItems = pendingMedia.drain(
+        evt.room_id,
+        inboundThreadRoot2(evt),
+        evt.sender ?? ""
+      );
+      const { blocks, pathLines } = await buildMediaBlocks(pendingItems, {
+        agent,
+        media: mediaClient,
+        writeAttachmentFn,
+        onError: (item, err) => {
+          console.warn(`[matrix:${agent.name}] media_failed for ${item.body}:`, err);
+          void sendMediaError(
+            { agent, roomId: evt.room_id, threadRoot },
+            err,
+            `Could not process attachment: ${item.body}`,
+            client
+          );
+        }
+      });
+      const fullPromptText = [promptText, ...pathLines].filter(Boolean).join("\n");
       await agents.prompt(agent.name, {
         threadId: sessionKey,
         channelId: evt.room_id,
-        content: [{ type: "text", text: promptText }]
+        content: [...blocks, { type: "text", text: fullPromptText }]
       });
       const drainStart = Date.now();
       let drained = buffers.get(sessionId) ?? "";
@@ -31591,10 +31850,11 @@ export {
   renderRegistration,
   ensureWorkforceSpace,
   ensureDefaultChannel,
+  MediaClient,
   createMatrixTransport,
   startWorkforcePublisher,
   SpawnRegistry,
   startDaemonSocketServer,
   buildAcpRegistry
 };
-//# sourceMappingURL=chunk-OKGNOROJ.js.map
+//# sourceMappingURL=chunk-R6EDLH23.js.map