@garuda-agent/garuda 0.0.1 → 0.15.0

package/dist/openaiCompatible-CJWVJP5M.js

@@ -0,0 +1,501 @@
+#!/usr/bin/env node
+import {
+  withoutServerBlocks
+} from "./chunk-A2QAIRQL.js";
+
+// src/model/textToolCalls.ts
+function extractTextToolCalls(text, toolNames2, mode = "whole") {
+  if (mode === "off" || toolNames2.size === 0) return void 0;
+  if (mode === "whole") {
+    const calls = wholeCalls(text.trim(), toolNames2);
+    return calls === void 0 ? void 0 : { calls, text: "" };
+  }
+  return lineCalls(text, toolNames2);
+}
+function mayBeToolCall(text) {
+  const start = text.trimStart();
+  if (start === "") return true;
+  if (START_TOKENS.some((token) => token.startsWith(start))) return true;
+  return /^(?:<tool_call>\s*|```(?:json)?\s*)?[[{]/.test(start);
+}
+var START_TOKENS = ["<tool_call>", "```json", "```"];
+var StreamHold = class {
+  constructor(mode) {
+    this.mode = mode;
+    this.holdRest = false;
+    if (mode === "off") this.released = true;
+  }
+  mode;
+  held = "";
+  /** "lines" mode: the current line, not yet decided. */
+  line = "";
+  /** "lines" mode: the current line is not a call; show it as it comes. */
+  lineShown = false;
+  holdRest;
+  released = false;
+  /** Take new text; return the text to show now. */
+  push(text) {
+    if (this.released) return text;
+    if (this.holdRest) {
+      this.held += text;
+      return "";
+    }
+    if (this.mode === "whole") {
+      this.held += text;
+      if (mayBeToolCall(this.held)) return "";
+      this.released = true;
+      const out = this.held;
+      this.held = "";
+      return out;
+    }
+    return this.pushLines(text);
+  }
+  /** The text held back at the end. It starts at the start of a line. */
+  rest() {
+    return this.held + this.line;
+  }
+  pushLines(text) {
+    this.line += text;
+    let out = "";
+    for (; ; ) {
+      const newline = this.line.indexOf("\n");
+      if (this.lineShown) {
+        if (newline === -1) {
+          out += this.line;
+          this.line = "";
+          return out;
+        }
+        out += this.line.slice(0, newline + 1);
+        this.line = this.line.slice(newline + 1);
+        this.lineShown = false;
+        continue;
+      }
+      const current = newline === -1 ? this.line : this.line.slice(0, newline);
+      if (current.trim() !== "" && !mayBeToolCall(current)) {
+        this.lineShown = true;
+        continue;
+      }
+      if (newline === -1) return out;
+      if (current.trim() === "") {
+        out += this.line.slice(0, newline + 1);
+        this.line = this.line.slice(newline + 1);
+        continue;
+      }
+      this.holdRest = true;
+      this.held = this.line;
+      this.line = "";
+      return out;
+    }
+  }
+};
+var MAX_JSON_LINES = 60;
+function lineCalls(text, toolNames2) {
+  const lines = text.split("\n");
+  const keep = [];
+  const calls = [];
+  let i = 0;
+  while (i < lines.length) {
+    const found = callsAt(lines, i, toolNames2);
+    if (found === void 0) {
+      keep.push(lines[i] ?? "");
+      i++;
+      continue;
+    }
+    if (found.calls.length === 0) keep.push(...lines.slice(i, found.next));
+    calls.push(...found.calls);
+    i = found.next;
+  }
+  if (calls.length === 0) return void 0;
+  return {
+    calls,
+    text: keep.join("\n").replace(/\n{3,}/g, "\n\n").trim()
+  };
+}
+function callsAt(lines, i, toolNames2) {
+  const first = (lines[i] ?? "").trim();
+  if (first.startsWith("```") || first.startsWith("<tool_call>")) {
+    const closing = first.startsWith("```") ? "```" : "</tool_call>";
+    for (let j = i; j < lines.length && j < i + MAX_JSON_LINES; j++) {
+      const line = (lines[j] ?? "").trim();
+      const closes = j === i ? line.length > 3 && line.endsWith(closing) : line.endsWith(closing);
+      if (!closes) continue;
+      const calls = wholeCalls(
+        lines.slice(i, j + 1).join("\n").trim(),
+        toolNames2
+      );
+      return { calls: calls ?? [], next: j + 1 };
+    }
+    return void 0;
+  }
+  if (!first.startsWith("{") && !first.startsWith("[")) return void 0;
+  for (let j = i; j < lines.length && j < i + MAX_JSON_LINES; j++) {
+    const calls = wholeCalls(
+      lines.slice(i, j + 1).join("\n").trim(),
+      toolNames2
+    );
+    if (calls !== void 0) return { calls, next: j + 1 };
+  }
+  return void 0;
+}
+function wholeCalls(text, toolNames2) {
+  const parts = unwrap(text);
+  if (parts === void 0 || parts.length === 0) return void 0;
+  const calls = [];
+  for (const part of parts) {
+    const values = parseJsonValues(part);
+    if (values === void 0) return void 0;
+    for (const value of values.flatMap((v) => Array.isArray(v) ? v : [v])) {
+      const call = toCall(value, toolNames2);
+      if (call === void 0) return void 0;
+      calls.push(call);
+    }
+  }
+  return calls.length === 0 ? void 0 : calls;
+}
+function unwrap(text) {
+  if (text.startsWith("<tool_call>")) return blocks(text, /<tool_call>([\s\S]*?)<\/tool_call>/g);
+  if (text.startsWith("```")) return blocks(text, /```(?:json)?[ \t]*\n?([\s\S]*?)```/g);
+  return [text];
+}
+function blocks(text, pattern) {
+  const inner = [];
+  let rest = text;
+  for (const match of text.matchAll(pattern)) {
+    rest = rest.replace(match[0], "");
+    inner.push((match[1] ?? "").trim());
+  }
+  return rest.trim() === "" ? inner : void 0;
+}
+function parseJsonValues(text) {
+  try {
+    return [JSON.parse(text)];
+  } catch {
+  }
+  const lines = text.split("\n").map((line) => line.trim()).filter((line) => line !== "");
+  if (lines.length < 2) return void 0;
+  const values = [];
+  for (const line of lines) {
+    try {
+      values.push(JSON.parse(line));
+    } catch {
+      return void 0;
+    }
+  }
+  return values;
+}
+function toCall(value, toolNames2) {
+  if (!isObject(value)) return void 0;
+  const name = value.name;
+  if (typeof name !== "string" || !toolNames2.has(name)) return void 0;
+  let input = value.arguments ?? value.parameters ?? {};
+  if (typeof input === "string") {
+    try {
+      input = JSON.parse(input);
+    } catch {
+      return void 0;
+    }
+  }
+  return isObject(input) ? { name, input } : void 0;
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/model/openaiCompatible.ts
+var RETRY_STATUS = /* @__PURE__ */ new Set([408, 409, 429, 500, 502, 503, 504]);
+var DEFAULT_RETRY_DELAYS = [1e3, 4e3];
+var MAX_RETRY_AFTER_MS = 3e4;
+var OpenAICompatibleClient = class {
+  constructor(options) {
+    this.options = options;
+    this.fetch = options.fetch ?? fetch;
+    this.delays = options.retryDelaysMs ?? DEFAULT_RETRY_DELAYS;
+  }
+  options;
+  fetch;
+  delays;
+  async *stream(request, options) {
+    const http = await this.post(toWireBody(this.options.model, request), options?.signal);
+    const mode = request.tools.length === 0 ? "off" : this.options.textToolCalls ?? "whole";
+    const state = newStreamState();
+    const hold = new StreamHold(mode);
+    for await (const data of sseData(http.body, options?.signal)) {
+      if (data === "[DONE]") break;
+      let chunk;
+      try {
+        chunk = JSON.parse(data);
+      } catch {
+        continue;
+      }
+      if (chunk.error !== void 0)
+        throw new Error(`${this.options.provider}: ${errorText(chunk.error)}`);
+      const shown = hold.push(applyChunk(state, chunk));
+      if (shown !== "") yield { type: "text_delta", text: shown };
+    }
+    const response = finishResponse(state, request, mode);
+    const held = hold.rest();
+    if (held !== "") {
+      const became = response.content.some((b) => b.type === "tool_use") && state.calls.size === 0;
+      const shown = became ? extractTextToolCalls(held, toolNames(request), mode)?.text ?? held : held;
+      if (shown.trim() !== "") yield { type: "text_delta", text: shown };
+    }
+    yield { type: "response", response };
+  }
+  async post(body, signal) {
+    const url = `${this.options.baseUrl.replace(/\/+$/, "")}/chat/completions`;
+    const headers = {
+      "content-type": "application/json",
+      accept: "text/event-stream"
+    };
+    if (this.options.apiKey !== void 0) headers.authorization = `Bearer ${this.options.apiKey}`;
+    for (let attempt = 0; ; attempt++) {
+      let response;
+      try {
+        response = await this.fetch(url, {
+          method: "POST",
+          headers,
+          body: JSON.stringify(body),
+          ...signal === void 0 ? {} : { signal }
+        });
+      } catch (error) {
+        if (signal?.aborted) throw error;
+        const cause = causeCode(error);
+        if (attempt < this.delays.length && cause !== "ECONNREFUSED") {
+          await sleep(this.delays[attempt] ?? 1e3, signal);
+          continue;
+        }
+        throw new Error(
+          cause === "ECONNREFUSED" ? `Cannot reach ${this.options.provider} at ${this.options.baseUrl}. Is the server running?` : `${this.options.provider}: ${error.message}`
+        );
+      }
+      if (response.ok && response.body !== null) return response;
+      const text = (await response.text().catch(() => "")).slice(0, 500);
+      if (RETRY_STATUS.has(response.status) && attempt < this.delays.length) {
+        const retryAfter = Number(response.headers.get("retry-after")) * 1e3;
+        const wait = Number.isFinite(retryAfter) && retryAfter > 0 ? Math.min(retryAfter, MAX_RETRY_AFTER_MS) : this.delays[attempt] ?? 1e3;
+        await sleep(wait, signal);
+        continue;
+      }
+      throw new Error(
+        `${this.options.provider} answered ${response.status}: ${httpErrorText(text)}`
+      );
+    }
+  }
+};
+function toWireBody(model, request) {
+  return {
+    model,
+    messages: toWireMessages(request.system, request.messages),
+    ...request.tools.length === 0 ? {} : { tools: toWireTools(request.tools) },
+    max_tokens: request.maxTokens,
+    stream: true,
+    stream_options: { include_usage: true }
+  };
+}
+function toWireTools(tools) {
+  return tools.map((tool) => ({
+    type: "function",
+    function: { name: tool.name, description: tool.description, parameters: tool.inputSchema }
+  }));
+}
+function toWireMessages(system, messages) {
+  const out = [{ role: "system", content: system }];
+  for (const message of messages) {
+    if (message.role === "assistant") {
+      const text = withoutServerBlocks(message.content).filter((b) => b.type === "text").map((b) => b.text).join("");
+      const calls = message.content.filter((b) => b.type === "tool_use");
+      out.push({
+        role: "assistant",
+        content: text === "" ? null : text,
+        ...calls.length === 0 ? {} : {
+          tool_calls: calls.map((c) => ({
+            id: c.id,
+            type: "function",
+            function: { name: c.name, arguments: JSON.stringify(c.input ?? {}) }
+          }))
+        }
+      });
+      continue;
+    }
+    const texts = [];
+    for (const block of message.content) {
+      if (block.type === "tool_result") {
+        out.push({
+          role: "tool",
+          tool_call_id: block.toolUseId,
+          content: block.isError ? `Error: ${block.content.replace(/^Error: /, "")}` : block.content
+        });
+      } else if (block.type === "text") {
+        texts.push(block.text);
+      }
+    }
+    if (texts.length > 0) out.push({ role: "user", content: texts.join("\n\n") });
+  }
+  return out;
+}
+function newStreamState() {
+  return { text: "", refusal: "", calls: /* @__PURE__ */ new Map(), finish: void 0, usage: void 0 };
+}
+function applyChunk(state, chunk) {
+  if (chunk.usage) state.usage = chunk.usage;
+  const choice = chunk.choices?.[0];
+  if (choice === void 0) return "";
+  if (choice.finish_reason) state.finish = choice.finish_reason;
+  const delta = choice.delta ?? {};
+  if (delta.refusal) state.refusal += delta.refusal;
+  for (const [position, call] of (delta.tool_calls ?? []).entries()) {
+    const index = call.index ?? position;
+    const entry = state.calls.get(index) ?? { name: "", args: "" };
+    if (call.id) entry.id = call.id;
+    if (call.function?.name) entry.name += call.function.name;
+    if (call.function?.arguments) entry.args += call.function.arguments;
+    state.calls.set(index, entry);
+  }
+  const text = delta.content ?? "";
+  state.text += text;
+  return text;
+}
+function finishResponse(state, request, mode = "whole") {
+  const content = [];
+  const text = state.text + (state.refusal === "" ? "" : state.refusal);
+  const newId = (n2) => `call_${Date.now().toString(36)}_${n2}`;
+  const fromText = state.calls.size === 0 && state.refusal === "" && state.finish !== "length" ? extractTextToolCalls(text, toolNames(request), mode) : void 0;
+  if (fromText !== void 0) {
+    if (fromText.text !== "") content.push({ type: "text", text: fromText.text });
+    for (const [i, call] of fromText.calls.entries())
+      content.push({ type: "tool_use", id: newId(i + 1), name: call.name, input: call.input });
+  } else if (text !== "") {
+    content.push({ type: "text", text });
+  }
+  let n = 0;
+  for (const [, call] of [...state.calls.entries()].sort(([a], [b]) => a - b)) {
+    if (call.name === "") continue;
+    n++;
+    content.push({
+      type: "tool_use",
+      id: call.id ?? newId(n),
+      name: call.name,
+      input: parseArguments(call.args)
+    });
+  }
+  return {
+    content,
+    stopReason: stopReason(state, content),
+    usage: usageOf(state, request, content)
+  };
+}
+function toolNames(request) {
+  return new Set(request.tools.map((t) => t.name));
+}
+function parseArguments(args) {
+  if (args.trim() === "") return {};
+  try {
+    return JSON.parse(args);
+  } catch {
+    return args;
+  }
+}
+function stopReason(state, content) {
+  if (state.refusal !== "" || state.finish === "content_filter") return "refusal";
+  if (content.some((b) => b.type === "tool_use")) return "tool_use";
+  if (state.finish === "length") return "max_tokens";
+  if (state.finish === "stop" || state.finish === void 0 || state.finish === "tool_calls")
+    return "end_turn";
+  return "other";
+}
+function usageOf(state, request, content) {
+  const u = state.usage;
+  if (u?.prompt_tokens !== void 0) {
+    const cached = u.prompt_tokens_details?.cached_tokens ?? 0;
+    return {
+      inputTokens: Math.max(0, u.prompt_tokens - cached),
+      outputTokens: u.completion_tokens ?? 0,
+      cacheReadTokens: cached,
+      cacheWriteTokens: 0
+    };
+  }
+  const chars = (value) => JSON.stringify(value).length;
+  return {
+    inputTokens: Math.ceil(
+      (request.system.length + chars(request.messages) + chars(request.tools)) / 4
+    ),
+    outputTokens: Math.ceil(chars(content) / 4),
+    cacheReadTokens: 0,
+    cacheWriteTokens: 0
+  };
+}
+async function* sseData(body, signal) {
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let data = [];
+  const reader = body.getReader();
+  const onAbort = () => void reader.cancel().catch(() => {
+  });
+  signal?.addEventListener("abort", onAbort, { once: true });
+  try {
+    for (; ; ) {
+      signal?.throwIfAborted();
+      const { value, done } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      let newline = buffer.indexOf("\n");
+      while (newline !== -1) {
+        const line = buffer.slice(0, newline).replace(/\r$/, "");
+        buffer = buffer.slice(newline + 1);
+        if (line === "") {
+          if (data.length > 0) yield data.join("\n");
+          data = [];
+        } else if (line.startsWith("data:")) {
+          data.push(line.slice(5).replace(/^ /, ""));
+        }
+        newline = buffer.indexOf("\n");
+      }
+    }
+    if (data.length > 0) yield data.join("\n");
+  } finally {
+    signal?.removeEventListener("abort", onAbort);
+    signal?.throwIfAborted();
+  }
+}
+function causeCode(error) {
+  const cause = error.cause;
+  return cause?.code ?? cause?.errors?.find((e) => e.code !== void 0)?.code;
+}
+function errorText(error) {
+  if (typeof error === "string") return error;
+  const message = error?.message;
+  return typeof message === "string" ? message : JSON.stringify(error).slice(0, 300);
+}
+function httpErrorText(body) {
+  let message = body;
+  try {
+    message = errorText(JSON.parse(body).error ?? body);
+  } catch {
+  }
+  const hint = /context|too long|maximum.*tokens|num_ctx/i.test(message) ? " (The conversation may be larger than the model's context window. Set contextWindow for this model in ~/.garuda/models.json.)" : "";
+  return `${message}${hint}`;
+}
+function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(resolve, ms);
+    signal?.addEventListener(
+      "abort",
+      () => {
+        clearTimeout(timer);
+        reject(signal.reason);
+      },
+      { once: true }
+    );
+  });
+}
+export {
+  OpenAICompatibleClient,
+  applyChunk,
+  finishResponse,
+  parseArguments,
+  sseData,
+  toWireBody,
+  toWireMessages,
+  toWireTools
+};
+//# sourceMappingURL=openaiCompatible-CJWVJP5M.js.map

package/dist/policy-EJPLEEXP.js

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+import {
+  POLICY_FILE,
+  assertModelAllowedByPolicy,
+  ignoredProjectPolicy,
+  isCommandDisallowedByPolicy,
+  isHostBlockedByPolicy,
+  isModelAllowedByPolicy,
+  isPathDeniedByPolicy,
+  isSandboxRequiredByPolicy,
+  loadTeamPolicy,
+  managedPolicyPath,
+  mergePolicies,
+  parsePolicy
+} from "./chunk-HUIK3WXO.js";
+import "./chunk-3NJNVZTK.js";
+export {
+  POLICY_FILE,
+  assertModelAllowedByPolicy,
+  ignoredProjectPolicy,
+  isCommandDisallowedByPolicy,
+  isHostBlockedByPolicy,
+  isModelAllowedByPolicy,
+  isPathDeniedByPolicy,
+  isSandboxRequiredByPolicy,
+  loadTeamPolicy,
+  managedPolicyPath,
+  mergePolicies,
+  parsePolicy
+};
+//# sourceMappingURL=policy-EJPLEEXP.js.map