@zhivex-ai/harness 1.4.0 → 1.4.1

package/dist/index-m49jx72n.js

@@ -1,220 +0,0 @@
-import {
-  VERTEX_TRANSIENT_ATTEMPTS,
-  classifyProviderFailure,
-  isEmptyModelTurn,
-  isRetryableProviderFailure,
-  providerDiagnostic,
-  providerDiagnosticSchema,
-  transientBackoffMs
-} from "./index-fm84men1.js";
-
-// src/providers/vertex-auth.ts
-import { GoogleAuth } from "google-auth-library";
-import { createVertex } from "@zhivex-ai/vertex";
-import { wrapLanguageModel } from "@zhivex-ai/core";
-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, retry) {
-  const route = vertexRoute(env);
-  const adapter = createVertex({
-    ...route,
-    getAccessToken: vertexTokenSource(env, route, createAuth)
-  })(model);
-  const attempts = retry?.attempts ?? VERTEX_TRANSIENT_ATTEMPTS;
-  const delayFor = (input) => retry?.delayMs ?? ((attempt) => input.retryBackoffMs === 0 ? 0 : transientBackoffMs(attempt, input.retryBackoffMs ?? 250));
-  const generate = async (input) => withVertexAttempts(input.abortSignal, vertexAttemptBudget(input, attempts), delayFor(input), async () => {
-    try {
-      return await adapter.generate({ ...input, maxRetries: 0 });
-    } catch (error) {
-      throw safeVertexError(error);
-    }
-  }, (result) => !isEmptyModelTurn(result));
-  const innerStream = adapter.stream?.bind(adapter);
-  const retrying = innerStream ? {
-    ...adapter,
-    generate,
-    async stream(input) {
-      const events = await withVertexAttempts(input.abortSignal, vertexAttemptBudget(input, attempts), delayFor(input), () => collectVertexStream(() => innerStream({ ...input, maxRetries: 0 })), (events2) => !isEmptyVertexStream(events2));
-      return replayVertexStream(events);
-    }
-  } : { ...adapter, generate };
-  return wrapLanguageModel(retrying, [{
-    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);
-        }
-      }();
-    }
-  }]);
-}
-async function collectVertexStream(next) {
-  let stream;
-  try {
-    stream = await next();
-  } catch (error) {
-    throw safeVertexError(error);
-  }
-  const events = [];
-  try {
-    for await (const event of stream) {
-      if (event.type === "error")
-        throw safeVertexError(event.error);
-      events.push(event);
-    }
-  } catch (error) {
-    throw error instanceof Error && error.message.startsWith("Vertex request failed.") ? error : safeVertexError(error);
-  }
-  return events;
-}
-function isEmptyVertexStream(events) {
-  let text = "";
-  let finishReason;
-  let tools = false;
-  let media = false;
-  for (const event of events) {
-    if (event.type === "text-delta")
-      text += event.textDelta;
-    else if (event.type === "tool-call" || event.type === "tool-approval-request")
-      tools = true;
-    else if (event.type === "image-generation")
-      media = true;
-    else if (event.type === "finish")
-      finishReason = event.finishReason;
-  }
-  return isEmptyModelTurn({
-    text,
-    finishReason,
-    ...tools ? { messages: [{ parts: [{ type: "tool-call" }] }] } : {},
-    ...media ? { images: [{}] } : {}
-  });
-}
-function replayVertexStream(events) {
-  return async function* () {
-    yield* events;
-  }();
-}
-async function withVertexAttempts(abortSignal, attempts, delayMs, run, accept) {
-  let last;
-  for (let attempt = 0;attempt < attempts; attempt += 1) {
-    if (abortSignal?.aborted)
-      throw new DOMException("Vertex request cancelled.", "AbortError");
-    try {
-      const value = await run();
-      if (accept(value) || attempt === attempts - 1)
-        return value;
-      last = value;
-    } catch (error) {
-      const safe = error instanceof Error && (error.name === "AbortError" || error.message.startsWith("Vertex request failed.")) ? error : safeVertexError(error);
-      if (safe.name === "AbortError" || abortSignal?.aborted || attempt === attempts - 1 || !isRetryableProviderFailure(safe))
-        throw safe;
-    }
-    await sleep(delayMs(attempt));
-  }
-  return last;
-}
-var sleep = (ms) => ms > 0 ? new Promise((resolve) => setTimeout(resolve, ms)) : Promise.resolve();
-function vertexAttemptBudget(input, fallback) {
-  const requested = [
-    typeof input.maxProviderRequests === "number" ? input.maxProviderRequests : undefined,
-    typeof input.maxRetries === "number" ? input.maxRetries + 1 : undefined
-  ].filter((value) => value !== undefined);
-  if (requested.length === 0)
-    return Math.max(1, fallback);
-  return Math.max(1, Math.min(...requested));
-}
-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 failure = classifyProviderFailure(error);
-  const body = providerBody(record.responseBody) ?? providerBody(record.body);
-  const preserved = providerDiagnosticSchema.safeParse(record.provider);
-  const provider = body !== undefined ? providerDiagnostic(body, failure.httpStatus) : preserved.success ? preserved.data : providerDiagnostic(undefined, failure.httpStatus);
-  return Object.assign(new Error("Vertex request failed. Check the sanitized provider diagnosis."), {
-    ...failure.httpStatus !== undefined ? { status: failure.httpStatus } : {},
-    ...failure.providerStatus ? { providerStatus: failure.providerStatus } : {},
-    provider,
-    retryable: failure.retryable
-  });
-}
-function providerBody(value) {
-  if (typeof value === "string")
-    return value;
-  if (!value || typeof value !== "object")
-    return;
-  try {
-    return JSON.stringify(value).slice(0, 8192);
-  } catch {
-    return;
-  }
-}
-
-export { vertexRoute, vertexConfigured, VERTEX_ENVIRONMENT, vertexEnvironment, vertexTokenSource, createVertexModel };