@infinityi/engine-lib 1.3.1 → 1.4.0

package/dist/index-mr1hs98z.js

@@ -0,0 +1,661 @@
+import {
+  fromJsonSchema
+} from "./index-k0q7x4mz.js";
+import {
+  combine,
+  exponentialBackoff,
+  retry,
+  timeout
+} from "./index-zdggff0y.js";
+import {
+  defineTool
+} from "./index-a67ej96j.js";
+
+// src/tools-http/events.ts
+var HTTP_EVENT = {
+  policy: "http.policy",
+  requestStart: "http.request.start",
+  requestEnd: "http.request.end"
+};
+function emit(ctx, name, data) {
+  ctx?.run?.emit({ type: "custom", name, data });
+}
+function emitHttpPolicy(ctx, decision, url, reason) {
+  emit(ctx, HTTP_EVENT.policy, {
+    decision,
+    url,
+    ...reason !== undefined ? { reason } : {}
+  });
+}
+function emitHttpRequestStart(ctx, method, url, timeoutMs) {
+  emit(ctx, HTTP_EVENT.requestStart, { method, url, timeoutMs });
+}
+function emitHttpRequestEnd(ctx, method, url, result, error) {
+  emit(ctx, HTTP_EVENT.requestEnd, {
+    method,
+    url,
+    ...result !== undefined ? {
+      finalUrl: result.finalUrl,
+      status: result.status,
+      elapsedMs: result.elapsedMs,
+      responseBytes: result.responseBytes,
+      responseBytesTruncated: result.responseBytesTruncated,
+      bodyTruncated: result.bodyTruncated
+    } : {},
+    ...error !== undefined ? { error } : {}
+  });
+}
+
+// src/tools-http/policy.ts
+var DEFAULT_PROTOCOLS = ["https:", "http:"];
+var DEFAULT_RESPONSE_HEADERS = [
+  "content-type",
+  "content-length",
+  "cache-control",
+  "etag",
+  "last-modified",
+  "location",
+  "retry-after"
+];
+
+class HttpPolicyError extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "HttpPolicyError";
+  }
+}
+function assertPositiveInteger(name, value) {
+  if (!Number.isInteger(value) || value <= 0) {
+    throw new HttpPolicyError(`${name} must be a positive integer`);
+  }
+}
+function assertNonNegativeInteger(name, value) {
+  if (!Number.isInteger(value) || value < 0) {
+    throw new HttpPolicyError(`${name} must be a non-negative integer`);
+  }
+}
+function normalizeProtocol(protocol) {
+  const trimmed = protocol.trim().toLowerCase();
+  return trimmed.endsWith(":") ? trimmed : `${trimmed}:`;
+}
+function normalizeHeaderName(name) {
+  const trimmed = name.trim().toLowerCase();
+  if (trimmed === "")
+    throw new HttpPolicyError("header name must be non-empty");
+  if (!/^[!#$%&'*+\-.^_`|~0-9a-z]+$/.test(trimmed)) {
+    throw new HttpPolicyError(`invalid header name ${JSON.stringify(name)}`);
+  }
+  return trimmed;
+}
+function headerEntries(headers) {
+  if (headers === undefined)
+    return [];
+  const entries = Array.isArray(headers) ? headers : Object.entries(headers).map(([name, value]) => ({ name, value }));
+  return entries.map((entry) => {
+    const name = normalizeHeaderName(entry.name);
+    if (typeof entry.value !== "string") {
+      throw new HttpPolicyError(`header ${JSON.stringify(entry.name)} value must be a string`);
+    }
+    if (/[\r\n]/.test(entry.value)) {
+      throw new HttpPolicyError(`header ${JSON.stringify(entry.name)} value contains a newline`);
+    }
+    return { name, value: entry.value };
+  });
+}
+function normalizeHttpConfig(config) {
+  const allowedHosts = config.allowedHosts ?? [];
+  const allowPublicInternet = config.allowPublicInternet ?? false;
+  if (!allowPublicInternet && allowedHosts.length === 0) {
+    throw new HttpPolicyError("tools-http requires allowedHosts or allowPublicInternet: true");
+  }
+  const allowedProtocols = (config.allowedProtocols ?? DEFAULT_PROTOCOLS).map(normalizeProtocol);
+  if (allowedProtocols.length === 0) {
+    throw new HttpPolicyError("allowedProtocols must contain at least one protocol");
+  }
+  const minTimeoutMs = config.minTimeoutMs ?? 100;
+  const defaultTimeoutMs = config.defaultTimeoutMs ?? 1e4;
+  const maxTimeoutMs = config.maxTimeoutMs ?? 60000;
+  const maxResponseBytes = config.maxResponseBytes ?? 1e6;
+  const maxBodyChars = config.maxBodyChars ?? 20000;
+  const maxRedirects = config.maxRedirects ?? 5;
+  const retryMaxAttempts = config.retry?.maxAttempts ?? 3;
+  const retryInitialDelayMs = config.retry?.initialDelayMs ?? 100;
+  const retryMaxDelayMs = config.retry?.maxDelayMs ?? 2000;
+  assertPositiveInteger("minTimeoutMs", minTimeoutMs);
+  assertPositiveInteger("defaultTimeoutMs", defaultTimeoutMs);
+  assertPositiveInteger("maxTimeoutMs", maxTimeoutMs);
+  if (minTimeoutMs > maxTimeoutMs) {
+    throw new HttpPolicyError("minTimeoutMs must be <= maxTimeoutMs");
+  }
+  assertPositiveInteger("maxResponseBytes", maxResponseBytes);
+  assertPositiveInteger("maxBodyChars", maxBodyChars);
+  assertNonNegativeInteger("maxRedirects", maxRedirects);
+  assertPositiveInteger("retry.maxAttempts", retryMaxAttempts);
+  assertNonNegativeInteger("retry.initialDelayMs", retryInitialDelayMs);
+  assertNonNegativeInteger("retry.maxDelayMs", retryMaxDelayMs);
+  return {
+    allowPublicInternet,
+    allowedHosts,
+    deniedHosts: config.deniedHosts ?? [],
+    allowedProtocols,
+    allowPrivateNetwork: config.allowPrivateNetwork ?? false,
+    allowCredentialedUrls: config.allowCredentialedUrls ?? false,
+    defaultHeaders: headerEntries(config.defaultHeaders),
+    allowedRequestHeaders: new Set((config.allowedRequestHeaders ?? []).map(normalizeHeaderName)),
+    responseHeaderAllowlist: new Set((config.responseHeaderAllowlist ?? DEFAULT_RESPONSE_HEADERS).map(normalizeHeaderName)),
+    defaultTimeoutMs: clamp(defaultTimeoutMs, minTimeoutMs, maxTimeoutMs),
+    minTimeoutMs,
+    maxTimeoutMs,
+    maxResponseBytes,
+    maxBodyChars,
+    maxRedirects,
+    retryMaxAttempts,
+    retryInitialDelayMs,
+    retryMaxDelayMs,
+    retryUnsafeMethods: config.retry?.retryUnsafeMethods ?? false,
+    fetch: config.fetch ?? fetch
+  };
+}
+function clamp(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}
+function cleanHostname(hostname) {
+  return hostname.toLowerCase().replace(/^\[/, "").replace(/\]$/, "").replace(/\.$/, "");
+}
+function cleanHost(host) {
+  return host.toLowerCase().replace(/\.$/, "");
+}
+function parsePatternHost(pattern) {
+  const trimmed = pattern.trim().toLowerCase();
+  if (/^[a-z][a-z0-9+.-]*:\/\//.test(trimmed)) {
+    return new URL(trimmed).host.toLowerCase();
+  }
+  return trimmed.replace(/\.$/, "");
+}
+function matchesHost(url, pattern) {
+  const hostname = cleanHostname(url.hostname);
+  const host = cleanHost(url.host);
+  if (pattern instanceof RegExp) {
+    pattern.lastIndex = 0;
+    return pattern.test(hostname) || pattern.test(host);
+  }
+  const value = parsePatternHost(pattern);
+  if (value === "*")
+    return true;
+  if (value.startsWith("*.")) {
+    const suffix = value.slice(1);
+    return hostname.endsWith(suffix) && hostname.length > suffix.length;
+  }
+  return value.includes(":") ? host === value : hostname === value;
+}
+function parseIPv4(hostname) {
+  const parts = hostname.split(".");
+  if (parts.length !== 4)
+    return null;
+  const numbers = parts.map((part) => {
+    if (!/^\d+$/.test(part))
+      return Number.NaN;
+    const value = Number(part);
+    return value >= 0 && value <= 255 ? value : Number.NaN;
+  });
+  return numbers.every((n) => Number.isInteger(n)) ? numbers : null;
+}
+function isPrivateIPv4(parts) {
+  const [a = 0, b = 0] = parts;
+  if (a === 0 || a === 10 || a === 127)
+    return true;
+  if (a === 100 && b >= 64 && b <= 127)
+    return true;
+  if (a === 169 && b === 254)
+    return true;
+  if (a === 172 && b >= 16 && b <= 31)
+    return true;
+  if (a === 192 && b === 168)
+    return true;
+  if (a >= 224)
+    return true;
+  return false;
+}
+function isPrivateIPv6(hostname) {
+  const value = hostname.toLowerCase();
+  if (value === "::" || value === "::1")
+    return true;
+  if (value.startsWith("fc") || value.startsWith("fd"))
+    return true;
+  if (/^fe[89ab]/.test(value))
+    return true;
+  if (value.startsWith("ff"))
+    return true;
+  const mapped = value.match(/^::ffff:(\d+\.\d+\.\d+\.\d+)$/);
+  if (mapped?.[1] !== undefined) {
+    const ipv4 = parseIPv4(mapped[1]);
+    return ipv4 !== null && isPrivateIPv4(ipv4);
+  }
+  return false;
+}
+function isPrivateTarget(hostname) {
+  const host = cleanHostname(hostname);
+  if (host === "localhost" || host.endsWith(".localhost"))
+    return true;
+  const ipv4 = parseIPv4(host);
+  if (ipv4 !== null)
+    return isPrivateIPv4(ipv4);
+  if (host.includes(":"))
+    return isPrivateIPv6(host);
+  return false;
+}
+function assertUrlAllowed(url, config) {
+  if (!config.allowedProtocols.includes(url.protocol.toLowerCase())) {
+    throw new HttpPolicyError(`protocol ${url.protocol} is not allowed`);
+  }
+  if (!config.allowCredentialedUrls && (url.username !== "" || url.password !== "")) {
+    throw new HttpPolicyError("credentialed URLs are not allowed");
+  }
+  if (!config.allowPrivateNetwork && isPrivateTarget(url.hostname)) {
+    throw new HttpPolicyError(`private or localhost target ${url.hostname} is not allowed`);
+  }
+  if (config.deniedHosts.some((pattern) => matchesHost(url, pattern))) {
+    throw new HttpPolicyError(`host ${url.host} is denied by policy`);
+  }
+  if (!config.allowPublicInternet && !config.allowedHosts.some((pattern) => matchesHost(url, pattern))) {
+    throw new HttpPolicyError(`host ${url.host} is not in allowedHosts`);
+  }
+}
+function buildRequestHeaders(config, modelHeaders, contentType, options) {
+  const headers = new Headers;
+  if (options?.includeConfiguredHeaders ?? true) {
+    for (const entry of config.defaultHeaders)
+      headers.set(entry.name, entry.value);
+    for (const entry of modelHeaders ?? []) {
+      const name = normalizeHeaderName(entry.name);
+      if (!config.allowedRequestHeaders.has(name))
+        continue;
+      if (/[\r\n]/.test(entry.value)) {
+        throw new HttpPolicyError(`header ${JSON.stringify(entry.name)} value contains a newline`);
+      }
+      headers.set(name, entry.value);
+    }
+  }
+  if (contentType !== undefined && !headers.has("content-type")) {
+    headers.set("content-type", contentType);
+  }
+  return headers;
+}
+function allowedResponseHeaders(headers, allowlist) {
+  const entries = [];
+  for (const [name, value] of headers.entries()) {
+    if (allowlist.has(name.toLowerCase()))
+      entries.push({ name, value });
+  }
+  return entries.sort((a, b) => a.name.localeCompare(b.name));
+}
+
+// src/tools-http/client.ts
+class RetryableHttpStatusError extends Error {
+  status;
+  constructor(status) {
+    super(`retryable HTTP status ${status}`);
+    this.name = "RetryableHttpStatusError";
+    this.status = status;
+  }
+}
+function messageOf(error) {
+  if (error instanceof Error)
+    return error.message;
+  return String(error);
+}
+function statusOf(error) {
+  if (typeof error === "object" && error !== null && "status" in error) {
+    const status = error.status;
+    if (typeof status === "number")
+      return status;
+  }
+  return;
+}
+function isAbort(error) {
+  return error instanceof DOMException && error.name === "AbortError";
+}
+function retryableStatus(status) {
+  return status === 429 || status >= 500;
+}
+function combineSignals(...signals) {
+  const present = signals.filter((signal) => signal !== undefined);
+  if (present.length === 0)
+    return;
+  if (present.length === 1)
+    return present[0];
+  return AbortSignal.any(present);
+}
+function timeoutFor(config, requested) {
+  if (requested === undefined || requested <= 0)
+    return config.defaultTimeoutMs;
+  return clamp(requested, config.minTimeoutMs, config.maxTimeoutMs);
+}
+function bytesFor(config, requested) {
+  if (requested === undefined || requested <= 0)
+    return config.maxResponseBytes;
+  return clamp(requested, 1, config.maxResponseBytes);
+}
+function charsFor(config, requested) {
+  if (requested === undefined || requested <= 0)
+    return config.maxBodyChars;
+  return clamp(requested, 1, config.maxBodyChars);
+}
+function shouldRetryMethod(config, method) {
+  return method === "GET" || config.retryUnsafeMethods;
+}
+function isTransient(error) {
+  if (isAbort(error))
+    return false;
+  const status = statusOf(error);
+  if (status === undefined)
+    return true;
+  return retryableStatus(status);
+}
+function redirectedMethod(method, status) {
+  if (status === 303)
+    return "GET";
+  if ((status === 301 || status === 302) && method === "POST")
+    return "GET";
+  return method;
+}
+function bodyFor(req, method) {
+  if (method === "GET")
+    return {};
+  if (req.body !== undefined && req.bodyJson !== undefined) {
+    throw new HttpPolicyError("body and bodyJson cannot both be supplied");
+  }
+  if (req.bodyJson !== undefined) {
+    return { body: JSON.stringify(req.bodyJson), contentType: req.contentType ?? "application/json" };
+  }
+  if (req.body !== undefined) {
+    return { body: req.body, contentType: req.contentType };
+  }
+  return {};
+}
+function contentKind(contentType) {
+  const type = (contentType ?? "").toLowerCase().split(";")[0]?.trim() ?? "";
+  if (type === "application/json" || type.endsWith("+json"))
+    return "json";
+  if (type.startsWith("text/"))
+    return "text";
+  if (type === "application/xhtml+xml" || type === "application/xml" || type.endsWith("+xml"))
+    return "text";
+  return "binary";
+}
+function truncateChars(text, maxChars) {
+  if (text.length <= maxChars)
+    return { text, truncated: false };
+  return { text: text.slice(0, maxChars), truncated: true };
+}
+async function readBytes(response, maxBytes) {
+  if (response.body === null)
+    return { bytes: new Uint8Array, truncated: false };
+  const reader = response.body.getReader();
+  const chunks = [];
+  let received = 0;
+  let truncated = false;
+  try {
+    while (true) {
+      const next = await reader.read();
+      if (next.done)
+        break;
+      const value = next.value;
+      if (received + value.byteLength > maxBytes) {
+        const remaining = Math.max(0, maxBytes - received);
+        if (remaining > 0)
+          chunks.push(value.slice(0, remaining));
+        received = maxBytes;
+        truncated = true;
+        await reader.cancel();
+        break;
+      }
+      chunks.push(value);
+      received += value.byteLength;
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  const out = new Uint8Array(received);
+  let offset = 0;
+  for (const chunk of chunks) {
+    out.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return { bytes: out, truncated };
+}
+function parseBody(bytes, responseBytesTruncated, contentType, maxBodyChars) {
+  const kind = contentKind(contentType);
+  if (kind === "binary") {
+    return { bodyOmitted: true, bodyTruncated: responseBytesTruncated };
+  }
+  const decoded = new TextDecoder().decode(bytes);
+  const truncated = truncateChars(decoded, maxBodyChars);
+  if (kind === "json" && !responseBytesTruncated && !truncated.truncated) {
+    try {
+      return {
+        bodyJson: decoded.length === 0 ? null : JSON.parse(decoded),
+        bodyOmitted: false,
+        bodyTruncated: false
+      };
+    } catch (error) {
+      throw new Error(`failed to parse JSON response: ${messageOf(error)}`);
+    }
+  }
+  return {
+    body: truncated.text,
+    bodyOmitted: false,
+    bodyTruncated: responseBytesTruncated || truncated.truncated
+  };
+}
+function validateUrl(raw) {
+  try {
+    return new URL(raw);
+  } catch (error) {
+    throw new HttpPolicyError(`invalid URL: ${messageOf(error)}`);
+  }
+}
+function checkUrl(url, config, ctx) {
+  try {
+    assertUrlAllowed(url, config);
+    emitHttpPolicy(ctx, "allow", url.href);
+  } catch (error) {
+    const message = messageOf(error);
+    emitHttpPolicy(ctx, "deny", url.href, message);
+    throw error;
+  }
+}
+async function cancelBody(response) {
+  try {
+    await response.body?.cancel();
+  } catch {}
+}
+function createHttpToolClient(config) {
+  const normalized = normalizeHttpConfig(config);
+  async function perform(req, ctx) {
+    let method = req.method;
+    let url = validateUrl(req.url);
+    checkUrl(url, normalized, ctx);
+    const timeoutMs = timeoutFor(normalized, req.timeoutMs);
+    const maxBytes = bytesFor(normalized, req.maxBytes);
+    const maxBodyChars = charsFor(normalized, req.maxBodyChars);
+    const started = performance.now();
+    const redirects = [];
+    const initialOrigin = url.origin;
+    emitHttpRequestStart(ctx, method, url.href, timeoutMs);
+    try {
+      for (let redirectCount = 0;redirectCount <= normalized.maxRedirects; redirectCount += 1) {
+        const currentMethod = method;
+        const currentUrl = url;
+        const { body, contentType } = bodyFor(req, currentMethod);
+        const requestHeaders = buildRequestHeaders(normalized, req.headers, contentType, {
+          includeConfiguredHeaders: currentUrl.origin === initialOrigin
+        });
+        const retryEnabled = shouldRetryMethod(normalized, currentMethod);
+        const maxAttempts = retryEnabled ? normalized.retryMaxAttempts : 1;
+        const pipeline = combine(retry({
+          maxAttempts,
+          backoff: exponentialBackoff({
+            initial: normalized.retryInitialDelayMs,
+            max: normalized.retryMaxDelayMs
+          }),
+          shouldRetry: (error) => {
+            if (ctx?.signal?.aborted)
+              return false;
+            return retryEnabled && isTransient(error);
+          }
+        }), timeout({ ms: timeoutMs }));
+        const response = await pipeline.execute(async (rctx) => {
+          const fetched = await normalized.fetch(currentUrl.href, {
+            method: currentMethod,
+            headers: requestHeaders,
+            body: currentMethod === "GET" ? undefined : body,
+            redirect: "manual",
+            signal: combineSignals(rctx.signal, ctx?.signal)
+          });
+          if (retryEnabled && retryableStatus(fetched.status) && rctx.attempt < maxAttempts) {
+            await cancelBody(fetched);
+            throw new RetryableHttpStatusError(fetched.status);
+          }
+          return fetched;
+        });
+        const location = response.headers.get("location");
+        if (response.status >= 300 && response.status < 400 && location !== null) {
+          if (redirectCount >= normalized.maxRedirects) {
+            await cancelBody(response);
+            throw new HttpPolicyError(`too many redirects (max ${normalized.maxRedirects})`);
+          }
+          const next = new URL(location, currentUrl);
+          await cancelBody(response);
+          checkUrl(next, normalized, ctx);
+          redirects.push(next.href);
+          method = redirectedMethod(method, response.status);
+          url = next;
+          continue;
+        }
+        const contentTypeHeader = response.headers.get("content-type") ?? undefined;
+        const { bytes, truncated } = await readBytes(response, maxBytes);
+        const parsed = parseBody(bytes, truncated, contentTypeHeader, maxBodyChars);
+        const result = {
+          url: req.url,
+          finalUrl: currentUrl.href,
+          redirected: redirects.length > 0,
+          redirects,
+          status: response.status,
+          statusText: response.statusText,
+          ...contentTypeHeader !== undefined ? { contentType: contentTypeHeader } : {},
+          headers: allowedResponseHeaders(response.headers, normalized.responseHeaderAllowlist),
+          ...parsed,
+          responseBytes: bytes.byteLength,
+          responseBytesTruncated: truncated,
+          elapsedMs: Math.round(performance.now() - started)
+        };
+        emitHttpRequestEnd(ctx, req.method, req.url, result);
+        return result;
+      }
+      throw new HttpPolicyError(`too many redirects (max ${normalized.maxRedirects})`);
+    } catch (error) {
+      const message = messageOf(error);
+      emitHttpRequestEnd(ctx, req.method, req.url, undefined, message);
+      throw error;
+    }
+  }
+  return {
+    request: perform,
+    get(url, options, ctx) {
+      return perform({ method: "GET", url, ...options ?? {} }, ctx);
+    },
+    post(url, options, ctx) {
+      return perform({ method: "POST", url, ...options ?? {} }, ctx);
+    }
+  };
+}
+// src/tools-http/define.ts
+var HEADER_SCHEMA = {
+  type: "array",
+  items: {
+    type: "object",
+    properties: {
+      name: { type: "string" },
+      value: { type: "string" }
+    },
+    required: ["name", "value"],
+    additionalProperties: false
+  }
+};
+var GET_PARAMS = fromJsonSchema({
+  type: "object",
+  properties: {
+    url: { type: "string", description: "Absolute http(s) URL to fetch." },
+    headers: HEADER_SCHEMA,
+    timeout_ms: { type: "integer", description: "Request timeout in milliseconds; clamped by host policy." },
+    max_bytes: { type: "integer", description: "Response byte cap; clamped by host policy." },
+    max_body_chars: { type: "integer", description: "Returned text character cap; clamped by host policy." }
+  },
+  required: ["url"],
+  additionalProperties: false
+});
+var POST_PARAMS = fromJsonSchema({
+  type: "object",
+  properties: {
+    url: { type: "string", description: "Absolute http(s) URL to fetch." },
+    headers: HEADER_SCHEMA,
+    body: { type: "string", description: "Raw request body." },
+    body_json: { description: "JSON value to serialize as the request body." },
+    content_type: { type: "string", description: "Content-Type for body/body_json when not already set." },
+    timeout_ms: { type: "integer", description: "Request timeout in milliseconds; clamped by host policy." },
+    max_bytes: { type: "integer", description: "Response byte cap; clamped by host policy." },
+    max_body_chars: { type: "integer", description: "Returned text character cap; clamped by host policy." }
+  },
+  required: ["url"],
+  additionalProperties: false
+});
+function fail(error) {
+  if (error instanceof Error)
+    return { ok: false, error: error.message };
+  return { ok: false, error: String(error) };
+}
+function httpTools(config) {
+  const client = createHttpToolClient(config);
+  const httpGet = defineTool({
+    name: "http_get",
+    description: "Fetch one HTTP(S) URL under the host network policy and return compact parsed response metadata.",
+    parameters: GET_PARAMS,
+    async execute(args, ctx) {
+      try {
+        const content = await client.get(args.url, {
+          headers: args.headers,
+          timeoutMs: args.timeout_ms,
+          maxBytes: args.max_bytes,
+          maxBodyChars: args.max_body_chars
+        }, ctx);
+        return { ok: true, content };
+      } catch (error) {
+        return fail(error);
+      }
+    }
+  });
+  const httpPost = defineTool({
+    name: "http_post",
+    description: "POST to one HTTP(S) URL under the host network policy and return compact parsed response metadata.",
+    parameters: POST_PARAMS,
+    async execute(args, ctx) {
+      try {
+        const content = await client.post(args.url, {
+          headers: args.headers,
+          body: args.body,
+          bodyJson: args.body_json,
+          contentType: args.content_type,
+          timeoutMs: args.timeout_ms,
+          maxBytes: args.max_bytes,
+          maxBodyChars: args.max_body_chars
+        }, ctx);
+        return { ok: true, content };
+      } catch (error) {
+        return fail(error);
+      }
+    }
+  });
+  return { httpGet, httpPost };
+}
+export { HTTP_EVENT, HttpPolicyError, createHttpToolClient, httpTools };

package/dist/{index-yrqrxwjt.js → index-nvdsr51v.js}

@@ -1,43 +1,9 @@
-import {
-  ContextWindowError
-} from "./index-7690reng.js";
 import {
   system
 } from "./index-1p6mb2vz.js";
-
-// src/context/providers.ts
-function renderItem(item) {
-  const body = typeof item.content === "string" ? item.content : JSON.stringify(item.content, null, 2) ?? "";
-  return item.title !== undefined && item.title !== "" ? `## ${item.title}
-${body}` : body;
-}
-function staticContext(content, title) {
-  const item = { content, ...title !== undefined ? { title } : {} };
-  return {
-    name: "static",
-    resolve: () => [item]
-  };
-}
-function dynamicContext(name, fn, title) {
-  return {
-    name,
-    resolve: async (ctx) => {
-      const content = await fn(ctx);
-      return [{ content, ...title !== undefined ? { title } : {} }];
-    }
-  };
-}
-async function resolveContext(providers, ctx) {
-  if (providers === undefined || providers.length === 0)
-    return [];
-  const resolved = await Promise.all(providers.map((p) => p.resolve(ctx)));
-  const blocks = resolved.flat().map(renderItem).filter((s) => s !== "");
-  if (blocks.length === 0)
-    return [];
-  return [system(blocks.join(`
-
-`))];
-}
+import {
+  ContextWindowError
+} from "./index-ajr3nk10.js";
 
 // src/context/window.ts
 function partChars(part) {
@@ -145,4 +111,4 @@ async function applyContextWindow(messages, window, ctx) {
   });
 }
 
-export { staticContext, dynamicContext, resolveContext, estimateTokens, truncateOldest, summarizeOldest, applyContextWindow };
+export { estimateTokens, truncateOldest, summarizeOldest, applyContextWindow };