neatlogs 1.0.6 → 1.0.9

package/dist/opencode-plugin.mjs

@@ -0,0 +1,644 @@
+// src/opencode-trace-shipper.ts
+import protobuf from "protobufjs";
+
+// src/version.ts
+var __version__ = "1.0.9";
+
+// src/opencode-trace-shipper.ts
+var PACKAGE_NAME = "neatlogs.opencode";
+var OTLP_PROTO_JSON = {
+  nested: {
+    opentelemetry: {
+      nested: {
+        proto: {
+          nested: {
+            common: {
+              nested: {
+                v1: {
+                  nested: {
+                    AnyValue: {
+                      oneofs: {
+                        value: {
+                          oneof: [
+                            "stringValue",
+                            "boolValue",
+                            "intValue",
+                            "doubleValue",
+                            "arrayValue",
+                            "kvlistValue",
+                            "bytesValue"
+                          ]
+                        }
+                      },
+                      fields: {
+                        stringValue: { type: "string", id: 1 },
+                        boolValue: { type: "bool", id: 2 },
+                        intValue: { type: "int64", id: 3 },
+                        doubleValue: { type: "double", id: 4 },
+                        arrayValue: { type: "ArrayValue", id: 5 },
+                        kvlistValue: { type: "KeyValueList", id: 6 },
+                        bytesValue: { type: "bytes", id: 7 }
+                      }
+                    },
+                    ArrayValue: { fields: { values: { rule: "repeated", type: "AnyValue", id: 1 } } },
+                    KeyValueList: { fields: { values: { rule: "repeated", type: "KeyValue", id: 1 } } },
+                    KeyValue: {
+                      fields: { key: { type: "string", id: 1 }, value: { type: "AnyValue", id: 2 } }
+                    },
+                    InstrumentationScope: {
+                      fields: { name: { type: "string", id: 1 }, version: { type: "string", id: 2 } }
+                    }
+                  }
+                }
+              }
+            },
+            resource: {
+              nested: {
+                v1: {
+                  nested: {
+                    Resource: {
+                      fields: {
+                        attributes: {
+                          rule: "repeated",
+                          type: "opentelemetry.proto.common.v1.KeyValue",
+                          id: 1
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            },
+            trace: {
+              nested: {
+                v1: {
+                  nested: {
+                    ResourceSpans: {
+                      fields: {
+                        resource: { type: "opentelemetry.proto.resource.v1.Resource", id: 1 },
+                        scopeSpans: { rule: "repeated", type: "ScopeSpans", id: 2 }
+                      }
+                    },
+                    ScopeSpans: {
+                      fields: {
+                        scope: { type: "opentelemetry.proto.common.v1.InstrumentationScope", id: 1 },
+                        spans: { rule: "repeated", type: "Span", id: 2 }
+                      }
+                    },
+                    Span: {
+                      fields: {
+                        traceId: { type: "bytes", id: 1 },
+                        spanId: { type: "bytes", id: 2 },
+                        traceState: { type: "string", id: 3 },
+                        parentSpanId: { type: "bytes", id: 4 },
+                        name: { type: "string", id: 5 },
+                        kind: { type: "SpanKind", id: 6 },
+                        startTimeUnixNano: { type: "fixed64", id: 7 },
+                        endTimeUnixNano: { type: "fixed64", id: 8 },
+                        attributes: {
+                          rule: "repeated",
+                          type: "opentelemetry.proto.common.v1.KeyValue",
+                          id: 9
+                        },
+                        droppedAttributesCount: { type: "uint32", id: 10 },
+                        status: { type: "Status", id: 15 }
+                      }
+                    },
+                    Status: {
+                      fields: { message: { type: "string", id: 2 }, code: { type: "StatusCode", id: 3 } }
+                    },
+                    StatusCode: {
+                      values: { STATUS_CODE_UNSET: 0, STATUS_CODE_OK: 1, STATUS_CODE_ERROR: 2 }
+                    },
+                    SpanKind: {
+                      values: {
+                        SPAN_KIND_UNSPECIFIED: 0,
+                        SPAN_KIND_INTERNAL: 1,
+                        SPAN_KIND_SERVER: 2,
+                        SPAN_KIND_CLIENT: 3,
+                        SPAN_KIND_PRODUCER: 4,
+                        SPAN_KIND_CONSUMER: 5
+                      }
+                    }
+                  }
+                }
+              }
+            },
+            collector: {
+              nested: {
+                trace: {
+                  nested: {
+                    v1: {
+                      nested: {
+                        ExportTraceServiceRequest: {
+                          fields: {
+                            resourceSpans: {
+                              rule: "repeated",
+                              type: "opentelemetry.proto.trace.v1.ResourceSpans",
+                              id: 1
+                            }
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+};
+var protoRoot = protobuf.Root.fromJSON(OTLP_PROTO_JSON);
+var ExportTraceServiceRequest = protoRoot.lookupType(
+  "opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest"
+);
+var SpanStatusCode = { UNSET: 0, OK: 1, ERROR: 2 };
+function randomBytes(length) {
+  const out = new Uint8Array(length);
+  const crypto = globalThis.crypto;
+  if (crypto && typeof crypto.getRandomValues === "function") {
+    crypto.getRandomValues(out);
+    return out;
+  }
+  for (let i = 0; i < out.length; i++) out[i] = Math.floor(Math.random() * 256);
+  return out;
+}
+function generateTraceId() {
+  return randomBytes(16);
+}
+function generateSpanId() {
+  return randomBytes(8);
+}
+function nowNanoString() {
+  return (BigInt(Date.now()) * 1000000n).toString();
+}
+function msToNanoString(ms) {
+  return (BigInt(Math.floor(ms)) * 1000000n).toString();
+}
+function attrStr(key, value) {
+  if (value === void 0 || value === null) return void 0;
+  return { key, value: { stringValue: String(value) } };
+}
+function attrInt(key, value) {
+  if (value === void 0 || value === null || !Number.isFinite(value)) return void 0;
+  return { key, value: { intValue: String(Math.trunc(value)) } };
+}
+function attrDouble(key, value) {
+  if (value === void 0 || value === null || !Number.isFinite(value)) return void 0;
+  return { key, value: { doubleValue: value } };
+}
+var TraceShipper = class {
+  apiKey;
+  endpoint;
+  debug;
+  maxRetries;
+  workflowName;
+  queue = [];
+  prefix = "[neatlogs/opencode]";
+  constructor(opts) {
+    this.apiKey = opts.apiKey;
+    this.endpoint = opts.endpoint.endsWith("/") ? opts.endpoint.slice(0, -1) : opts.endpoint;
+    this.debug = !!opts.debug;
+    this.maxRetries = opts.maxRetries ?? 3;
+    this.workflowName = opts.workflowName || "";
+  }
+  enqueue(span) {
+    this.queue.push(span);
+  }
+  get pending() {
+    return this.queue.length;
+  }
+  /**
+   * Ship all queued spans in a single awaited POST. Resolves only once the HTTP
+   * response is received (or all retries are exhausted) — so a short-lived host
+   * can safely exit immediately after awaiting this.
+   */
+  async flush() {
+    if (this.queue.length === 0) return;
+    if (!this.apiKey) {
+      this.queue = [];
+      return;
+    }
+    const spans = this.queue.splice(0);
+    const payload = this.buildProtobuf(spans);
+    const url = `${this.endpoint}/v1/traces`;
+    if (this.debug) console.log(`${this.prefix} Shipping ${spans.length} spans to ${url}`);
+    for (let attempt = 1; attempt <= this.maxRetries; attempt++) {
+      try {
+        const resp = await fetch(url, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/x-protobuf",
+            "x-api-key": this.apiKey
+          },
+          body: payload
+        });
+        if (resp.ok) {
+          if (this.debug) console.log(`${this.prefix} Shipped ${spans.length} spans`);
+          return;
+        }
+        if (resp.status === 401) {
+          console.warn(`${this.prefix} Invalid API key (401) \u2014 dropping ${spans.length} spans`);
+          return;
+        }
+        if (resp.status < 500 && resp.status !== 429) {
+          if (this.debug) console.warn(`${this.prefix} HTTP ${resp.status} \u2014 dropping spans`);
+          return;
+        }
+      } catch (err) {
+        if (this.debug) {
+          console.warn(
+            `${this.prefix} Attempt ${attempt}/${this.maxRetries}: ${err.message}`
+          );
+        }
+      }
+      if (attempt < this.maxRetries) {
+        await new Promise((r) => setTimeout(r, 500 * 2 ** (attempt - 1)));
+      }
+    }
+    console.warn(`${this.prefix} Failed to ship ${spans.length} spans after ${this.maxRetries} attempts`);
+  }
+  buildProtobuf(spans) {
+    const protoSpans = spans.map((span) => ({
+      traceId: span.traceId,
+      spanId: span.spanId,
+      parentSpanId: span.parentSpanId || void 0,
+      name: span.name,
+      kind: span.kind,
+      startTimeUnixNano: nanoToLong(span.startTimeUnixNano),
+      endTimeUnixNano: nanoToLong(span.endTimeUnixNano),
+      attributes: span.attributes.map((a) => ({
+        key: a.key,
+        value: a.value.intValue !== void 0 ? { intValue: nanoToLong(a.value.intValue) } : a.value
+      })),
+      status: span.status ? { code: span.status.code, message: span.status.message } : void 0
+    }));
+    const resourceAttributes = [
+      { key: "service.name", value: { stringValue: "neatlogs.opencode" } },
+      { key: "service.version", value: { stringValue: __version__ } }
+    ];
+    if (this.workflowName) {
+      resourceAttributes.push({
+        key: "neatlogs.workflow_name",
+        value: { stringValue: this.workflowName }
+      });
+    }
+    const message = {
+      resourceSpans: [
+        {
+          resource: { attributes: resourceAttributes },
+          scopeSpans: [
+            {
+              scope: { name: PACKAGE_NAME, version: __version__ },
+              spans: protoSpans
+            }
+          ]
+        }
+      ]
+    };
+    const errMsg = ExportTraceServiceRequest.verify(message);
+    if (errMsg && this.debug) console.warn(`${this.prefix} Proto verify: ${errMsg}`);
+    return ExportTraceServiceRequest.encode(ExportTraceServiceRequest.fromObject(message)).finish();
+  }
+};
+function nanoToLong(nanoStr) {
+  const big = BigInt(nanoStr);
+  const low = Number(big & 0xffffffffn);
+  const high = Number(big >> 32n & 0xffffffffn);
+  return { low, high, unsigned: true };
+}
+
+// src/opencode-plugin.ts
+var DEFAULT_ENDPOINT = "https://staging-cloud.neatlogs.com";
+var NeatlogsOpencodePlugin = async (_ctx) => {
+  const apiKey = (process.env.NEATLOGS_API_KEY ?? "").trim();
+  const endpoint = (process.env.NEATLOGS_ENDPOINT ?? DEFAULT_ENDPOINT).trim();
+  const workflowName = process.env.NEATLOGS_WORKFLOW_NAME || "opencode";
+  const captureSystemPrompt = String(process.env.NEATLOGS_CAPTURE_SYSTEM_PROMPT || "").toLowerCase() === "true";
+  const debug = String(process.env.NEATLOGS_DEBUG || "").toLowerCase() === "true";
+  const shipper = new TraceShipper({ apiKey, endpoint, workflowName, debug });
+  const sessions = /* @__PURE__ */ new Map();
+  function stateFor(sessionID) {
+    let s = sessions.get(sessionID);
+    if (!s) {
+      s = {
+        traceId: generateTraceId(),
+        toolStarts: /* @__PURE__ */ new Map(),
+        outputParts: /* @__PURE__ */ new Map(),
+        toolCalls: /* @__PURE__ */ new Map(),
+        processed: /* @__PURE__ */ new Set(),
+        currentInput: "",
+        lastAssistantText: ""
+      };
+      sessions.set(sessionID, s);
+    }
+    return s;
+  }
+  function startRoot(st, sessionID) {
+    if (st.rootSpan) return;
+    st.rootSpan = {
+      spanId: generateSpanId(),
+      name: "opencode.session",
+      startNano: nowNanoString(),
+      attributes: [
+        { key: "neatlogs.span.kind", value: { stringValue: "AGENT" } },
+        { key: "neatlogs.agent.framework", value: { stringValue: "opencode" } },
+        { key: "neatlogs.conversation.id", value: { stringValue: sessionID } }
+      ]
+    };
+  }
+  async function closeAndFlush(st, sessionID) {
+    if (st.rootSpan) {
+      const attrs = st.rootSpan.attributes.slice();
+      setIO(attrs, "AGENT", st.currentInput || void 0, st.lastAssistantText || void 0);
+      shipper.enqueue({
+        traceId: st.traceId,
+        spanId: st.rootSpan.spanId,
+        name: st.rootSpan.name,
+        kind: 1,
+        startTimeUnixNano: st.rootSpan.startNano,
+        endTimeUnixNano: nowNanoString(),
+        attributes: attrs,
+        status: { code: SpanStatusCode.OK }
+      });
+      const m = nowNanoString();
+      shipper.enqueue({
+        traceId: st.traceId,
+        spanId: generateSpanId(),
+        parentSpanId: st.rootSpan.spanId,
+        name: "neatlogs.trace.complete",
+        kind: 1,
+        startTimeUnixNano: m,
+        endTimeUnixNano: m,
+        attributes: [
+          { key: "neatlogs.trace.complete", value: { boolValue: true } },
+          { key: "neatlogs.internal", value: { boolValue: true } },
+          { key: "neatlogs.span.kind", value: { stringValue: "Neatlogs.INTERNAL" } }
+        ]
+      });
+      st.rootSpan = void 0;
+    }
+    await shipper.flush();
+    void sessionID;
+  }
+  return {
+    /** Fired when the user submits a prompt — open the turn's AGENT root. */
+    "chat.message": async (_input, output) => {
+      try {
+        const sessionID = String(_input?.sessionID ?? output?.sessionID ?? "");
+        if (!sessionID) return;
+        const st = stateFor(sessionID);
+        const parts = output?.parts ?? [];
+        const text = Array.isArray(parts) ? parts.filter((p) => p?.type === "text" && typeof p.text === "string").map((p) => p.text).join("\n") : "";
+        if (text) st.currentInput = text;
+        startRoot(st, sessionID);
+      } catch {
+      }
+    },
+    /** Capture the system prompt (opt-in). */
+    "experimental.chat.system.transform": async (_input, output) => {
+      try {
+        if (!captureSystemPrompt) return;
+        const sessionID = String(_input?.sessionID ?? "");
+        const parts = output?.system ?? output?.parts ?? output;
+        const joined = Array.isArray(parts) ? parts.map((p) => typeof p === "string" ? p : p?.text ?? "").join("\n") : String(parts ?? "");
+        if (sessionID && joined) stateFor(sessionID).systemPrompt = joined;
+      } catch {
+      }
+    },
+    /** Global event bus — message parts, assistant completions, session idle. */
+    event: async ({ event }) => {
+      try {
+        await handleEvent(shipper, sessions, stateFor, startRoot, closeAndFlush, event);
+      } catch {
+      }
+    },
+    /** Tool start — record start time + args (span built atomically in `after`). */
+    "tool.execute.before": async (input, output) => {
+      try {
+        const sessionID = String(input?.sessionID ?? "");
+        if (!sessionID) return;
+        const st = stateFor(sessionID);
+        startRoot(st, sessionID);
+        const callID = String(input?.callID ?? input?.tool ?? "");
+        st.toolStarts.set(callID, {
+          spanId: generateSpanId(),
+          startNano: nowNanoString(),
+          tool: String(input?.tool ?? "tool"),
+          args: output?.args
+        });
+      } catch {
+      }
+    },
+    /** Tool end — enqueue the completed TOOL span (parented to the turn root). */
+    "tool.execute.after": async (input, result) => {
+      try {
+        const sessionID = String(input?.sessionID ?? "");
+        if (!sessionID) return;
+        const st = stateFor(sessionID);
+        const callID = String(input?.callID ?? input?.tool ?? "");
+        const start = st.toolStarts.get(callID);
+        if (!start) return;
+        st.toolStarts.delete(callID);
+        const attrs = [
+          { key: "neatlogs.span.kind", value: { stringValue: "TOOL" } },
+          { key: "neatlogs.tool.name", value: { stringValue: start.tool } },
+          { key: "neatlogs.conversation.id", value: { stringValue: sessionID } }
+        ];
+        if (start.args !== void 0) {
+          setIO(attrs, "TOOL", safeStringify(start.args), void 0);
+          push(attrs, attrStr("neatlogs.tool.input", safeStringify(start.args)));
+        }
+        if (result?.title) push(attrs, attrStr("neatlogs.tool.title", String(result.title)));
+        const out = result?.output ?? result?.result;
+        if (out !== void 0) {
+          const o = typeof out === "string" ? out : safeStringify(out);
+          setIO(attrs, "TOOL", void 0, o);
+          push(attrs, attrStr("neatlogs.tool.output", o));
+        }
+        if (result?.metadata !== void 0) {
+          push(attrs, attrStr("neatlogs.tool.metadata", safeStringify(result.metadata)));
+        }
+        shipper.enqueue({
+          traceId: st.traceId,
+          spanId: start.spanId,
+          parentSpanId: st.rootSpan?.spanId,
+          name: `opencode.tool.${start.tool}`,
+          kind: 1,
+          startTimeUnixNano: start.startNano,
+          endTimeUnixNano: nowNanoString(),
+          attributes: attrs,
+          status: { code: SpanStatusCode.OK }
+        });
+      } catch {
+      }
+    }
+  };
+};
+var neatlogsOpencodePlugin = NeatlogsOpencodePlugin;
+var opencode_plugin_default = NeatlogsOpencodePlugin;
+function handleEvent(shipper, sessions, stateFor, startRoot, closeAndFlush, event) {
+  const type = event?.type;
+  const props = event?.properties ?? {};
+  if (type === "message.part.updated" || type === "message.part.completed") {
+    const part = props.part ?? props;
+    const messageID = part?.messageID ?? part?.message_id;
+    const sessionID = part?.sessionID ?? props.sessionID;
+    if (!messageID || !sessionID) return void 0;
+    const st = stateFor(String(sessionID));
+    if (part?.type === "text" && typeof part?.text === "string") {
+      st.outputParts.set(String(messageID), part.text);
+    } else if (part?.type === "tool" && part?.tool) {
+      const list = st.toolCalls.get(String(messageID)) ?? [];
+      const callID = String(part.callID ?? part.tool);
+      const input = part?.state?.input ?? {};
+      const existing = list.find((t) => t.callID === callID);
+      if (existing) existing.input = input;
+      else list.push({ name: String(part.tool), input, callID });
+      st.toolCalls.set(String(messageID), list);
+    }
+    return void 0;
+  }
+  if (type === "message.updated" || type === "message.completed") {
+    const info = props.info ?? props.message ?? props;
+    const sessionID = info?.sessionID ?? info?.session_id;
+    if (!sessionID) return void 0;
+    if (info?.role !== "assistant") return void 0;
+    const completed = info?.time?.completed ?? info?.completed;
+    const id = String(info?.id ?? "");
+    if (!completed || !id) return void 0;
+    const st = stateFor(String(sessionID));
+    if (st.processed.has(id)) return void 0;
+    st.processed.add(id);
+    startRoot(st, String(sessionID));
+    emitLlmSpan(shipper, st, info, String(sessionID));
+    return shipper.flush().catch(() => void 0);
+  }
+  if (type === "session.idle" || type === "session.deleted") {
+    const sessionID = props.sessionID ?? props.info?.id;
+    if (!sessionID) return void 0;
+    const st = sessions.get(String(sessionID));
+    if (!st) return void 0;
+    st.toolStarts.clear();
+    const p = closeAndFlush(st, String(sessionID));
+    if (type === "session.deleted") sessions.delete(String(sessionID));
+    return p;
+  }
+  return void 0;
+}
+function emitLlmSpan(shipper, st, info, sessionID) {
+  const model = info?.modelID ?? info?.model ?? "";
+  const provider = info?.providerID ?? info?.provider ?? "";
+  const attrs = [
+    { key: "neatlogs.span.kind", value: { stringValue: "LLM" } },
+    { key: "neatlogs.conversation.id", value: { stringValue: sessionID } }
+  ];
+  push(attrs, attrStr("neatlogs.llm.model_name", model ? String(model) : void 0));
+  push(attrs, attrStr("neatlogs.llm.provider", provider ? String(provider) : void 0));
+  let inIdx = 0;
+  if (st.systemPrompt) {
+    push(attrs, attrStr(`neatlogs.llm.input_messages.${inIdx}.role`, "system"));
+    push(attrs, attrStr(`neatlogs.llm.input_messages.${inIdx}.content`, st.systemPrompt));
+    inIdx++;
+  }
+  if (st.currentInput) {
+    push(attrs, attrStr(`neatlogs.llm.input_messages.${inIdx}.role`, "user"));
+    push(attrs, attrStr(`neatlogs.llm.input_messages.${inIdx}.content`, st.currentInput));
+    setIO(attrs, "LLM", st.currentInput, void 0);
+  }
+  const outText = st.outputParts.get(String(info?.id)) || messageText(info) || "";
+  const toolCalls = st.toolCalls.get(String(info?.id)) ?? [];
+  if (outText) {
+    push(attrs, attrStr("neatlogs.llm.output_messages.0.role", "assistant"));
+    push(attrs, attrStr("neatlogs.llm.output_messages.0.content", outText));
+    setIO(attrs, "LLM", void 0, outText);
+    st.lastAssistantText = outText;
+  }
+  if (toolCalls.length) {
+    toolCalls.forEach((tc, j) => {
+      push(attrs, attrStr(`neatlogs.llm.tool_calls.${j}.name`, tc.name));
+      push(attrs, attrStr(`neatlogs.llm.tool_calls.${j}.arguments`, safeStringify(tc.input ?? {})));
+    });
+    if (!outText) {
+      const rendered = toolCalls.map((tc) => `\u2192 ${tc.name}(${safeStringify(tc.input ?? {})})`).join("\n");
+      push(attrs, attrStr("neatlogs.llm.output_messages.0.role", "assistant"));
+      push(attrs, attrStr("neatlogs.llm.output_messages.0.content", rendered));
+      setIO(attrs, "LLM", void 0, rendered);
+    }
+  }
+  const tokens = info?.tokens;
+  if (tokens) {
+    push(attrs, attrInt("neatlogs.llm.token_count.prompt", tokens.input));
+    push(attrs, attrInt("neatlogs.llm.token_count.completion", tokens.output));
+    if (tokens.input != null && tokens.output != null) {
+      push(attrs, attrInt("neatlogs.llm.token_count.total", tokens.input + tokens.output));
+    }
+    push(attrs, attrInt("neatlogs.llm.token_count.reasoning", tokens.reasoning));
+    push(attrs, attrInt("neatlogs.llm.token_count.cache_read", tokens.cache?.read));
+    push(attrs, attrInt("neatlogs.llm.token_count.cache_write", tokens.cache?.write));
+  }
+  push(attrs, attrDouble("neatlogs.llm.cost_usd", info?.cost));
+  const createdMs = info?.time?.created;
+  const startNano = typeof createdMs === "number" ? msToNanoString(Math.floor(createdMs)) : nowNanoString();
+  shipper.enqueue({
+    traceId: st.traceId,
+    spanId: generateSpanId(),
+    parentSpanId: st.rootSpan?.spanId,
+    name: `opencode.llm.${model || "model"}`,
+    kind: 1,
+    startTimeUnixNano: startNano,
+    endTimeUnixNano: nowNanoString(),
+    attributes: attrs,
+    status: { code: SpanStatusCode.OK }
+  });
+  if (info?.id) {
+    st.outputParts.delete(String(info.id));
+    st.toolCalls.delete(String(info.id));
+  }
+}
+function push(arr, kv) {
+  if (kv) arr.push(kv);
+}
+function setIO(arr, kind, input, output) {
+  const k = kind.toLowerCase();
+  if (input !== void 0) {
+    push(arr, attrStr("input.value", input));
+    push(arr, attrStr("neatlogs.input.value", input));
+    push(arr, attrStr(`neatlogs.${k}.input`, input));
+  }
+  if (output !== void 0) {
+    push(arr, attrStr("output.value", output));
+    push(arr, attrStr("neatlogs.output.value", output));
+    push(arr, attrStr(`neatlogs.${k}.output`, output));
+  }
+}
+function messageText(info) {
+  if (!info) return "";
+  if (typeof info.text === "string") return info.text;
+  const parts = info.parts ?? info.content;
+  if (typeof parts === "string") return parts;
+  if (!Array.isArray(parts)) return "";
+  const out = [];
+  for (const p of parts) {
+    if (typeof p === "string") out.push(p);
+    else if (p && typeof p === "object" && typeof p.text === "string") out.push(p.text);
+  }
+  return out.join("");
+}
+function safeStringify(value) {
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value) ?? "";
+  } catch {
+    return String(value);
+  }
+}
+export {
+  NeatlogsOpencodePlugin,
+  opencode_plugin_default as default,
+  neatlogsOpencodePlugin
+};
+//# sourceMappingURL=opencode-plugin.mjs.map