@hachej/boring-agent 0.1.78 → 0.1.79

package/dist/chunk-Q42DWR3T.js

@@ -0,0 +1,264 @@
+import {
+  AgentDefinitionErrorCode,
+  AgentDeploymentErrorCode,
+  ErrorCode
+} from "./chunk-YVON2BHN.js";
+
+// src/shared/agent-definition.ts
+import { z } from "zod";
+var SHA256_DIGEST_RE = /^sha256:[a-f0-9]{64}$/;
+function hasWellFormedUnicode(value) {
+  for (let index = 0; index < value.length; index += 1) {
+    const code = value.charCodeAt(index);
+    if (code >= 55296 && code <= 56319) {
+      if (index + 1 >= value.length) return false;
+      const next = value.charCodeAt(index + 1);
+      if (next < 56320 || next > 57343) return false;
+      index += 1;
+    } else if (code >= 56320 && code <= 57343) {
+      return false;
+    }
+  }
+  return true;
+}
+function isOpaqueRef(value) {
+  return hasWellFormedUnicode(value) && value.trim() === value && !/[\0-\x1f\x7f]/.test(value);
+}
+function isSafeAssetPath(value) {
+  const segments = value.split("/");
+  return hasWellFormedUnicode(value) && value.normalize("NFC") === value && !/[\0-\x1f\x7f]/.test(value) && !value.includes("\\") && !value.startsWith("/") && !/^[A-Za-z]:[\\/]/.test(value) && !value.startsWith("./") && segments.every((segment) => segment !== "" && segment !== "." && segment !== "..");
+}
+var OpaqueRefSchema = z.string().min(1, "must be a non-empty reference").max(256, "must be at most 256 characters").refine(isOpaqueRef, "must be a non-empty reference");
+var ReferenceArraySchema = z.array(OpaqueRefSchema).superRefine((refs, ctx) => {
+  const seen = /* @__PURE__ */ new Set();
+  refs.forEach((ref, index) => {
+    if (seen.has(ref)) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: [index],
+        message: "must not contain duplicate references"
+      });
+    }
+    seen.add(ref);
+  });
+});
+var SafeAssetPathSchema = z.string().min(1).refine(isSafeAssetPath, "must be a safe relative asset path");
+var Sha256DigestSchema = z.string().regex(SHA256_DIGEST_RE, "must be a lowercase sha256 digest").transform((value) => value);
+var AgentDefinitionSchema = z.object({
+  schemaVersion: z.literal(1),
+  definitionId: OpaqueRefSchema,
+  version: OpaqueRefSchema,
+  label: z.string().refine(hasWellFormedUnicode, "must contain well-formed Unicode").optional(),
+  instructionsRef: SafeAssetPathSchema,
+  capabilityRequirements: ReferenceArraySchema.optional(),
+  toolRefs: ReferenceArraySchema.optional(),
+  skillRefs: ReferenceArraySchema.optional(),
+  mcpServerRefs: ReferenceArraySchema.optional()
+}).strict();
+var AgentDefinitionReferenceSchema = z.object({
+  definitionId: OpaqueRefSchema,
+  version: OpaqueRefSchema,
+  digest: Sha256DigestSchema
+}).strict();
+var AgentDeploymentSchema = z.object({
+  deploymentId: OpaqueRefSchema,
+  version: OpaqueRefSchema,
+  agentId: OpaqueRefSchema,
+  definition: AgentDefinitionReferenceSchema
+}).strict();
+var AgentDefinitionDigestAssetSchema = z.object({
+  path: SafeAssetPathSchema,
+  digest: Sha256DigestSchema,
+  content: z.string().refine(hasWellFormedUnicode, "must contain well-formed Unicode")
+}).strict();
+function formatPath(path) {
+  if (path.length === 0) return "<root>";
+  return path.reduce(
+    (result, part) => typeof part === "number" ? `${result}[${part}]` : result.length === 0 ? String(part) : `${result}.${String(part)}`,
+    ""
+  );
+}
+function mapZodIssues(issues, invalidCode, unsupportedCode) {
+  return issues.flatMap((issue) => {
+    if (issue.code === z.ZodIssueCode.unrecognized_keys) {
+      const parent = formatPath(issue.path);
+      return [...issue.keys].sort().map((key) => ({
+        code: unsupportedCode,
+        field: parent === "<root>" ? key : `${parent}.${key}`,
+        message: `${key} is not supported by schema version 1`
+      }));
+    }
+    const field = formatPath(issue.path);
+    return [{
+      code: invalidCode,
+      field,
+      message: field === "<root>" ? issue.message : `${field} ${issue.message}`
+    }];
+  });
+}
+function validateAgentDefinition(raw) {
+  const result = AgentDefinitionSchema.safeParse(raw);
+  if (!result.success) {
+    return {
+      valid: false,
+      issues: mapZodIssues(
+        result.error.issues,
+        AgentDefinitionErrorCode.enum.AGENT_DEFINITION_INVALID,
+        AgentDefinitionErrorCode.enum.AGENT_DEFINITION_UNSUPPORTED_FIELD
+      )
+    };
+  }
+  return { valid: true, value: result.data };
+}
+function validateAgentDeployment(raw) {
+  const result = AgentDeploymentSchema.safeParse(raw);
+  if (!result.success) {
+    return {
+      valid: false,
+      issues: mapZodIssues(
+        result.error.issues,
+        AgentDeploymentErrorCode.enum.AGENT_DEPLOYMENT_INVALID,
+        AgentDeploymentErrorCode.enum.AGENT_DEPLOYMENT_UNSUPPORTED_FIELD
+      )
+    };
+  }
+  return { valid: true, value: result.data };
+}
+function canonicalStringify(value) {
+  if (value === null || typeof value !== "object") {
+    const encoded = JSON.stringify(value);
+    if (encoded === void 0) throw new TypeError("Cannot canonicalize undefined");
+    return encoded;
+  }
+  if (Array.isArray(value)) return `[${value.map(canonicalStringify).join(",")}]`;
+  const record = value;
+  return `{${Object.keys(record).filter((key) => record[key] !== void 0).sort().map((key) => `${JSON.stringify(key)}:${canonicalStringify(record[key])}`).join(",")}}`;
+}
+async function sha256(value) {
+  const hash = await globalThis.crypto.subtle.digest(
+    "SHA-256",
+    new TextEncoder().encode(value)
+  );
+  const hex = Array.from(
+    new Uint8Array(hash),
+    (byte) => byte.toString(16).padStart(2, "0")
+  ).join("");
+  return `sha256:${hex}`;
+}
+async function createAgentAssetDigest(content) {
+  if (!hasWellFormedUnicode(content)) {
+    throw new AgentDefinitionValidationError({
+      code: AgentDefinitionErrorCode.enum.AGENT_DEFINITION_INVALID,
+      field: "content",
+      message: "content must contain well-formed Unicode"
+    });
+  }
+  return sha256(content);
+}
+var AgentDefinitionValidationError = class extends Error {
+  code = ErrorCode.enum.CONFIG_INVALID;
+  field;
+  validationCode;
+  constructor(issue) {
+    super(issue.message);
+    this.name = "AgentDefinitionValidationError";
+    this.field = issue.field;
+    this.validationCode = issue.code;
+  }
+};
+var AgentDeploymentValidationError = class extends Error {
+  code = ErrorCode.enum.CONFIG_INVALID;
+  field;
+  validationCode;
+  constructor(issue) {
+    super(issue.message);
+    this.name = "AgentDeploymentValidationError";
+    this.field = issue.field;
+    this.validationCode = issue.code;
+  }
+};
+async function validatedDefinitionAssets(definition, assets) {
+  if (!Array.isArray(assets)) {
+    throw new AgentDefinitionValidationError({
+      code: AgentDefinitionErrorCode.enum.AGENT_DEFINITION_INVALID,
+      field: "assets",
+      message: "assets must be an array"
+    });
+  }
+  const canonicalAssets = [];
+  for (const [index, input] of assets.entries()) {
+    const result = AgentDefinitionDigestAssetSchema.safeParse(input);
+    if (!result.success) {
+      const issue = mapZodIssues(
+        result.error.issues,
+        AgentDefinitionErrorCode.enum.AGENT_DEFINITION_INVALID,
+        AgentDefinitionErrorCode.enum.AGENT_DEFINITION_UNSUPPORTED_FIELD
+      )[0];
+      throw new AgentDefinitionValidationError({
+        ...issue,
+        field: `assets[${index}].${issue.field}`
+      });
+    }
+    if (await createAgentAssetDigest(result.data.content) !== result.data.digest) {
+      throw new AgentDefinitionValidationError({
+        code: AgentDefinitionErrorCode.enum.AGENT_DEFINITION_INVALID,
+        field: "assets.digest",
+        message: `asset digest does not match UTF-8 content: ${result.data.path}`
+      });
+    }
+    canonicalAssets.push(result.data);
+  }
+  canonicalAssets.sort(
+    (left, right) => left.path < right.path ? -1 : left.path > right.path ? 1 : 0
+  );
+  for (let index = 1; index < canonicalAssets.length; index += 1) {
+    if (canonicalAssets[index - 1].path === canonicalAssets[index].path) {
+      throw new AgentDefinitionValidationError({
+        code: AgentDefinitionErrorCode.enum.AGENT_DEFINITION_INVALID,
+        field: "assets.path",
+        message: `duplicate asset path: ${canonicalAssets[index].path}`
+      });
+    }
+  }
+  if (!canonicalAssets.some((asset) => asset.path === definition.instructionsRef)) {
+    throw new AgentDefinitionValidationError({
+      code: AgentDefinitionErrorCode.enum.AGENT_DEFINITION_INVALID,
+      field: "instructionsRef",
+      message: "instructionsRef must name an included verified asset"
+    });
+  }
+  return canonicalAssets;
+}
+async function createAgentDefinitionDigest(input) {
+  const validated = validateAgentDefinition(input.definition);
+  if (!validated.valid) throw new AgentDefinitionValidationError(validated.issues[0]);
+  const assets = await validatedDefinitionAssets(validated.value, input.assets);
+  return sha256(canonicalStringify({ definition: validated.value, assets }));
+}
+async function createAgentDeploymentDigest(deployment) {
+  const validated = validateAgentDeployment(deployment);
+  if (!validated.valid) throw new AgentDeploymentValidationError(validated.issues[0]);
+  return sha256(canonicalStringify(validated.value));
+}
+
+// src/shared/validateTool.ts
+function validateTool(tool) {
+  if (typeof tool !== "object" || tool === null) return null;
+  const t = tool;
+  if (typeof t.name !== "string" || t.name.length === 0) return null;
+  if (typeof t.description !== "string") return null;
+  if (typeof t.parameters !== "object" || t.parameters === null) return null;
+  if (typeof t.execute !== "function") return null;
+  return t;
+}
+
+export {
+  validateAgentDefinition,
+  validateAgentDeployment,
+  createAgentAssetDigest,
+  AgentDefinitionValidationError,
+  AgentDeploymentValidationError,
+  createAgentDefinitionDigest,
+  createAgentDeploymentDigest,
+  validateTool
+};