@nyte-ai/ai 0.0.0-stage → 0.0.19

package/dist/chunks/account-limits-cache-kjx405q0.js

@@ -0,0 +1,277 @@
+// src/utils/validation.ts
+import { Compile } from "typebox/compile";
+import { Type } from "typebox";
+import { Value } from "typebox/value";
+var validatorCache = new WeakMap;
+var TYPEBOX_KIND = Symbol.for("TypeBox.Kind");
+var JsonRecordSchema = Type.Record(Type.String(), Type.Unknown());
+function getSchemaTypes(schema) {
+  if (schema.type === undefined)
+    return [];
+  return Array.isArray(schema.type) ? schema.type : [schema.type];
+}
+function matchesJsonType(value, type) {
+  switch (type) {
+    case "number":
+      return typeof value === "number";
+    case "integer":
+      return typeof value === "number" && Number.isInteger(value);
+    case "boolean":
+      return typeof value === "boolean";
+    case "string":
+      return typeof value === "string";
+    case "null":
+      return value === null;
+    case "array":
+      return Array.isArray(value);
+    case "object":
+      return typeof value === "object" && value !== null && !Array.isArray(value);
+    default:
+      return false;
+  }
+}
+function getSubSchemaValidator(schema) {
+  try {
+    return getValidator(schema);
+  } catch {
+    return;
+  }
+}
+function coercePrimitiveByType(value, type) {
+  switch (type) {
+    case "number": {
+      if (value === null) {
+        return 0;
+      }
+      if (typeof value === "string" && value.trim() !== "") {
+        const parsed = Number(value);
+        if (Number.isFinite(parsed)) {
+          return parsed;
+        }
+      }
+      if (typeof value === "boolean") {
+        return value ? 1 : 0;
+      }
+      return value;
+    }
+    case "integer": {
+      if (value === null) {
+        return 0;
+      }
+      if (typeof value === "string" && value.trim() !== "") {
+        const parsed = Number(value);
+        if (Number.isInteger(parsed)) {
+          return parsed;
+        }
+      }
+      if (typeof value === "boolean") {
+        return value ? 1 : 0;
+      }
+      return value;
+    }
+    case "boolean": {
+      if (value === null) {
+        return false;
+      }
+      if (typeof value === "string") {
+        if (value === "true") {
+          return true;
+        }
+        if (value === "false") {
+          return false;
+        }
+      }
+      if (typeof value === "number") {
+        if (value === 1) {
+          return true;
+        }
+        if (value === 0) {
+          return false;
+        }
+      }
+      return value;
+    }
+    case "string": {
+      if (value === null) {
+        return "";
+      }
+      if (typeof value === "number" || typeof value === "boolean") {
+        return String(value);
+      }
+      return value;
+    }
+    case "null": {
+      if (value === "" || value === 0 || value === false) {
+        return null;
+      }
+      return value;
+    }
+    default:
+      return value;
+  }
+}
+function applySchemaObjectCoercion(value, schema) {
+  const properties = schema.properties;
+  const definedKeys = new Set(properties ? Object.keys(properties) : []);
+  if (properties) {
+    for (const [key, propertySchema] of Object.entries(properties)) {
+      if (!(key in value)) {
+        continue;
+      }
+      value[key] = coerceWithJsonSchema(value[key], propertySchema);
+    }
+  }
+  if (schema.additionalProperties && schema.additionalProperties !== true) {
+    for (const [key, propertyValue] of Object.entries(value)) {
+      if (definedKeys.has(key)) {
+        continue;
+      }
+      value[key] = coerceWithJsonSchema(propertyValue, schema.additionalProperties);
+    }
+  }
+}
+function applySchemaArrayCoercion(value, schema) {
+  if (Array.isArray(schema.items)) {
+    for (let index = 0;index < value.length; index++) {
+      const itemSchema = schema.items[index];
+      if (!itemSchema) {
+        continue;
+      }
+      value[index] = coerceWithJsonSchema(value[index], itemSchema);
+    }
+    return;
+  }
+  if (schema.items) {
+    for (let index = 0;index < value.length; index++) {
+      value[index] = coerceWithJsonSchema(value[index], schema.items);
+    }
+  }
+}
+function coerceWithUnionSchema(value, schemas) {
+  for (const schema of schemas) {
+    const validator = getSubSchemaValidator(schema);
+    if (validator?.Check(value)) {
+      return value;
+    }
+  }
+  for (const schema of schemas) {
+    const candidate = structuredClone(value);
+    const coerced = coerceWithJsonSchema(candidate, schema);
+    const validator = getSubSchemaValidator(schema);
+    if (validator?.Check(coerced)) {
+      return coerced;
+    }
+  }
+  return value;
+}
+function coerceWithJsonSchema(value, schema) {
+  let nextValue = value;
+  if (Array.isArray(schema.allOf)) {
+    for (const nested of schema.allOf) {
+      nextValue = coerceWithJsonSchema(nextValue, nested);
+    }
+  }
+  if (Array.isArray(schema.anyOf)) {
+    nextValue = coerceWithUnionSchema(nextValue, schema.anyOf);
+  }
+  if (Array.isArray(schema.oneOf)) {
+    nextValue = coerceWithUnionSchema(nextValue, schema.oneOf);
+  }
+  const schemaTypes = getSchemaTypes(schema);
+  const matchesUnionMember = schemaTypes.length > 1 && schemaTypes.some((schemaType) => matchesJsonType(nextValue, schemaType));
+  if (schemaTypes.length > 0 && !matchesUnionMember) {
+    for (const schemaType of schemaTypes) {
+      const candidate = coercePrimitiveByType(nextValue, schemaType);
+      if (candidate !== nextValue) {
+        nextValue = candidate;
+        break;
+      }
+    }
+  }
+  if (schemaTypes.includes("object") && Value.Check(JsonRecordSchema, nextValue)) {
+    applySchemaObjectCoercion(nextValue, schema);
+  }
+  if (schemaTypes.includes("array") && Array.isArray(nextValue)) {
+    applySchemaArrayCoercion(nextValue, schema);
+  }
+  return nextValue;
+}
+function normalizeOptionalNulls(value, schema) {
+  if (Array.isArray(value)) {
+    if (Array.isArray(schema.items)) {
+      for (let index = 0;index < value.length; index++) {
+        const itemSchema = schema.items[index];
+        if (itemSchema)
+          normalizeOptionalNulls(value[index], itemSchema);
+      }
+    } else if (schema.items) {
+      for (const item of value)
+        normalizeOptionalNulls(item, schema.items);
+    }
+    return;
+  }
+  if (!Value.Check(JsonRecordSchema, value) || !schema.properties)
+    return;
+  const object = value;
+  const required = new Set(schema.required ?? []);
+  for (const [key, propertySchema] of Object.entries(schema.properties)) {
+    if (!(key in object))
+      continue;
+    if (object[key] === null && !required.has(key) && propertySchema.$ref === undefined && getSubSchemaValidator(propertySchema)?.Check(null) === false) {
+      delete object[key];
+    } else {
+      normalizeOptionalNulls(object[key], propertySchema);
+    }
+  }
+}
+function getValidator(schema) {
+  if (typeof schema !== "object")
+    return Compile(schema);
+  const key = schema;
+  const cached = validatorCache.get(key);
+  if (cached) {
+    return cached;
+  }
+  const validator = Compile(schema);
+  validatorCache.set(key, validator);
+  return validator;
+}
+function formatValidationPath(error) {
+  if (error.keyword === "required") {
+    const requiredProperty = error.params.requiredProperties[0];
+    if (requiredProperty) {
+      const basePath = error.instancePath.replace(/^\//, "").replace(/\//g, ".");
+      return basePath ? `${basePath}.${requiredProperty}` : requiredProperty;
+    }
+  }
+  const path = error.instancePath.replace(/^\//, "").replace(/\//g, ".");
+  return path || "root";
+}
+function validateToolArguments2(tool, toolCall) {
+  if (toolCall.argumentsError !== undefined) {
+    throw new Error(`Invalid arguments for tool "${toolCall.name}": ${toolCall.argumentsError}`);
+  }
+  return parseToolArguments(tool.parameters, toolCall.arguments, toolCall.name, getValidator(tool.parameters));
+}
+function createToolArgumentParser2(tool) {
+  const schema = tool.parameters;
+  const validator = Compile(schema);
+  return (args) => parseToolArguments(schema, args, tool.name, validator);
+}
+function parseToolArguments(schema, input, name, validator) {
+  const args = structuredClone(input);
+  normalizeOptionalNulls(args, schema);
+  Value.Convert(schema, args);
+  const coerced = Object.getOwnPropertySymbols(schema).includes(TYPEBOX_KIND) ? args : coerceWithJsonSchema(args, schema);
+  if (validator.Check(coerced))
+    return coerced;
+  const errors = validator.Errors(coerced).map((error) => `  - ${formatValidationPath(error)}: ${error.message}`).join(`
+`) || "Unknown validation error";
+  throw new Error(`Validation failed for tool "${name}":
+${errors}
+
+Received arguments:
+${JSON.stringify(input, null, 2)}`);
+}
+
+export { validateToolArguments2, createToolArgumentParser2 };

package/dist/chunks/account-limits-cache-ks1sjym9.js

@@ -0,0 +1,37 @@
+// src/api/claude-code.ts
+var claudeCodeVersion2 = "2.1.280";
+var claudeCodeTools = [
+  "Read",
+  "Write",
+  "Edit",
+  "Bash",
+  "Grep",
+  "Glob",
+  "AskUserQuestion",
+  "EnterPlanMode",
+  "ExitPlanMode",
+  "KillShell",
+  "NotebookEdit",
+  "Skill",
+  "Task",
+  "TaskOutput",
+  "TodoWrite",
+  "WebFetch",
+  "WebSearch"
+];
+var ccToolLookup = new Map(claudeCodeTools.map((t) => [t.toLowerCase(), t]));
+var toClaudeCodeName2 = (name) => ccToolLookup.get(name.toLowerCase()) ?? name;
+var fromClaudeCodeName2 = (name, tools) => {
+  if (tools && tools.length > 0) {
+    const lowerName = name.toLowerCase();
+    const matchedTool = tools.find((tool) => tool.name.toLowerCase() === lowerName);
+    if (matchedTool)
+      return matchedTool.name;
+  }
+  return name;
+};
+function usesClaudeSubscription2(apiKey) {
+  return apiKey.includes("sk-ant-oat");
+}
+
+export { claudeCodeVersion2, toClaudeCodeName2, fromClaudeCodeName2, usesClaudeSubscription2 };

package/dist/chunks/account-limits-cache-me1x57bs.js

@@ -0,0 +1,89 @@
+// src/utils/sse.ts
+var LINE_BREAK = /\r\n|\r|\n/;
+var FIELD = /^([^:]*):? ?(.*)$/s;
+function flushEvent(state) {
+  if (state.event === null && state.data.length === 0)
+    return;
+  const event = {
+    event: state.event,
+    data: state.data.join(`
+`),
+    raw: state.raw
+  };
+  state.event = null;
+  state.data = [];
+  state.raw = [];
+  return event;
+}
+function decodeLine(line, state) {
+  if (line === "")
+    return flushEvent(state);
+  state.raw.push(line);
+  if (line.startsWith(":"))
+    return;
+  const [, field = "", value = ""] = FIELD.exec(line) ?? [];
+  if (field === "event")
+    state.event = value;
+  else if (field === "data")
+    state.data.push(value);
+  return;
+}
+function* takeLines(buffer, final) {
+  for (let match = LINE_BREAK.exec(buffer.text);match; match = LINE_BREAK.exec(buffer.text)) {
+    if (!final && match[0] === "\r" && match.index === buffer.text.length - 1)
+      return;
+    yield buffer.text.slice(0, match.index);
+    buffer.text = buffer.text.slice(match.index + match[0].length);
+  }
+}
+async function* iterateServerSentEvents2(body, signal, idleTimeoutMs) {
+  const reader = body.getReader();
+  const cancel = () => reader.cancel().catch(() => {
+    return;
+  });
+  signal?.addEventListener("abort", cancel, { once: true });
+  const decoder = new TextDecoder;
+  const state = { event: null, data: [], raw: [] };
+  const buffer = { text: "" };
+  let idleTimer;
+  let idleTimedOut = false;
+  try {
+    for (;; ) {
+      if (signal?.aborted)
+        throw new Error("Request was aborted");
+      if (idleTimeoutMs !== undefined && idleTimeoutMs > 0) {
+        idleTimer = setTimeout(() => {
+          idleTimedOut = true;
+          cancel();
+        }, idleTimeoutMs);
+      }
+      const { value, done } = await reader.read();
+      clearTimeout(idleTimer);
+      if (signal?.aborted)
+        throw new Error("Request was aborted");
+      if (idleTimedOut)
+        throw new DOMException("SSE idle timeout", "TimeoutError");
+      buffer.text += done ? decoder.decode() : decoder.decode(value, { stream: true });
+      for (const line of takeLines(buffer, done)) {
+        const event = decodeLine(line, state);
+        if (event)
+          yield event;
+      }
+      if (done)
+        break;
+    }
+    const trailing = buffer.text.length > 0 ? decodeLine(buffer.text, state) : undefined;
+    if (trailing)
+      yield trailing;
+    const last = flushEvent(state);
+    if (last)
+      yield last;
+  } finally {
+    clearTimeout(idleTimer);
+    signal?.removeEventListener("abort", cancel);
+    await cancel();
+    reader.releaseLock();
+  }
+}
+
+export { iterateServerSentEvents2 };