@zhivex-ai/harness 1.3.0-rc.3 → 1.3.0

package/dist/index-8705zxpr.js

@@ -0,0 +1,145 @@
+// src/providers/vertex-auth.ts
+import { GoogleAuth } from "google-auth-library";
+import { createVertex } from "@zhivex-ai/vertex";
+import { wrapLanguageModel } from "@zhivex-ai/core";
+
+// src/runtime/provider-diagnostics.ts
+import { z } from "zod";
+var providerDiagnosticSchema = z.strictObject({
+  reason: z.enum(["previous_response_unavailable", "context_length_exceeded", "authentication", "payment_required", "permission", "rate_limit", "model_unavailable", "invalid_request", "server_error", "unknown"]),
+  parameter: z.enum(["previous_response_id", "input", "messages", "tools", "model", "max_output_tokens", "max_tokens", "temperature", "other", "none"]),
+  bodyState: z.enum(["parsed", "malformed", "too_large", "unavailable", "read_timeout"])
+});
+function providerDiagnostic(body, status) {
+  let reason = status === 401 ? "authentication" : status === 402 ? "payment_required" : status === 403 ? "permission" : status === 429 ? "rate_limit" : status && status >= 500 ? "server_error" : "unknown";
+  let parameter = "none";
+  if (typeof body !== "string")
+    return { reason, parameter, bodyState: "unavailable" };
+  if (Buffer.byteLength(body) > 8192)
+    return { reason, parameter, bodyState: "too_large" };
+  try {
+    const parsed = JSON.parse(body);
+    const detail = parsed?.error ?? parsed;
+    const code = [detail?.code, detail?.status, detail?.type].find((value) => typeof value === "string") ?? "";
+    const message = typeof detail?.message === "string" ? detail.message : "";
+    const param = providerDiagnosticSchema.shape.parameter.safeParse(detail?.param);
+    parameter = param.success ? param.data : detail?.param == null ? "none" : "other";
+    if (/response/i.test(message) && /not found|expired/i.test(message) && (parameter === "previous_response_id" || parameter === "none"))
+      reason = "previous_response_unavailable";
+    else if (["context_length_exceeded", "context_window_exceeded"].includes(code))
+      reason = "context_length_exceeded";
+    else if (["invalid_api_key", "authentication_error", "UNAUTHENTICATED"].includes(code))
+      reason = "authentication";
+    else if (["permission_denied", "permission_error", "PERMISSION_DENIED"].includes(code))
+      reason = "permission";
+    else if (["rate_limit_exceeded", "rate_limit_error", "RESOURCE_EXHAUSTED"].includes(code))
+      reason = "rate_limit";
+    else if (["model_not_found", "model_not_available", "NOT_FOUND"].includes(code))
+      reason = "model_unavailable";
+    else if (["invalid_request_error", "INVALID_ARGUMENT"].includes(code) || status === 400 || status === 422)
+      reason = "invalid_request";
+    return { reason, parameter, bodyState: "parsed" };
+  } catch {
+    return { reason, parameter, bodyState: "malformed" };
+  }
+}
+
+// src/providers/vertex-auth.ts
+var CLOUD_PLATFORM_SCOPE = "https://www.googleapis.com/auth/cloud-platform";
+function vertexRoute(env) {
+  const projectId = (env.GOOGLE_CLOUD_PROJECT ?? "").trim();
+  const location = (env.VERTEX_LOCATION ?? "").trim();
+  if (!/^(?:[a-z][a-z0-9-]{4,61}[a-z0-9]|[0-9]{6,20})$/.test(projectId)) {
+    throw new Error("Vertex requires a valid GOOGLE_CLOUD_PROJECT.");
+  }
+  if (!/^(?:global|us|eu|[a-z]+-[a-z]+[0-9]+)$/.test(location)) {
+    throw new Error("Vertex requires an explicit valid VERTEX_LOCATION.");
+  }
+  return Object.freeze({ projectId, location });
+}
+function vertexConfigured(env) {
+  try {
+    vertexRoute(env);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var VERTEX_ENVIRONMENT = ["GOOGLE_CLOUD_PROJECT", "VERTEX_LOCATION", "GOOGLE_APPLICATION_CREDENTIALS"];
+function vertexEnvironment(env) {
+  return Object.fromEntries(VERTEX_ENVIRONMENT.flatMap((name) => env[name] ? [[name, env[name]]] : []));
+}
+function vertexTokenSource(env, route, createAuth = (options) => new GoogleAuth(options)) {
+  const keyFilename = env.GOOGLE_APPLICATION_CREDENTIALS?.trim();
+  const auth = createAuth({
+    projectId: route.projectId,
+    scopes: [CLOUD_PLATFORM_SCOPE],
+    ...keyFilename ? { keyFilename } : {}
+  });
+  return async () => {
+    try {
+      const token = await auth.getAccessToken();
+      if (!token)
+        throw new Error("Empty ADC token");
+      return token;
+    } catch {
+      throw new VertexAuthenticationError;
+    }
+  };
+}
+
+class VertexAuthenticationError extends Error {
+  status = 401;
+  retryable = false;
+  constructor() {
+    super("Vertex ADC credentials are unavailable or could not be refreshed. Configure Application Default Credentials and retry.");
+    this.name = "VertexAuthenticationError";
+  }
+}
+function createVertexModel(model, env, createAuth) {
+  const route = vertexRoute(env);
+  const adapter = createVertex({
+    ...route,
+    getAccessToken: vertexTokenSource(env, route, createAuth)
+  })(model);
+  return wrapLanguageModel(adapter, [{
+    name: "harness-vertex-sanitized-errors",
+    async wrapGenerate(_context, next) {
+      try {
+        return await next();
+      } catch (error) {
+        throw safeVertexError(error);
+      }
+    },
+    async wrapStream(_context, next) {
+      let stream;
+      try {
+        stream = await next();
+      } catch (error) {
+        throw safeVertexError(error);
+      }
+      return async function* () {
+        try {
+          yield* stream;
+        } catch (error) {
+          throw safeVertexError(error);
+        }
+      }();
+    }
+  }]);
+}
+function safeVertexError(error) {
+  if (error instanceof VertexAuthenticationError)
+    return error;
+  const record = error && typeof error === "object" ? error : {};
+  if (record.name === "AbortError")
+    return new DOMException("Vertex request cancelled.", "AbortError");
+  const status = typeof record.status === "number" && Number.isInteger(record.status) && record.status >= 100 && record.status <= 599 ? record.status : undefined;
+  return Object.assign(new Error("Vertex request failed. Check the sanitized provider diagnosis."), {
+    ...status ? { status } : {},
+    provider: providerDiagnostic(record.responseBody ?? record.body, status),
+    retryable: record.retryable === true
+  });
+}
+
+export { providerDiagnosticSchema, providerDiagnostic, vertexRoute, vertexConfigured, VERTEX_ENVIRONMENT, vertexEnvironment, vertexTokenSource, createVertexModel };