@zhivex-ai/harness 1.2.0 → 1.3.0-rc.7

package/dist/index-qfpz5y2v.js

@@ -0,0 +1,174 @@
+// src/client/stream.ts
+var CLI_JSON_SCHEMA_VERSION = 1;
+var CLI_EVENT_SCHEMA_VERSION = 1;
+var streamEventDocument = (event, sequence = 0) => {
+  if (!Number.isSafeInteger(sequence) || sequence < 0) {
+    throw new Error("JSONL event sequence must be a non-negative integer.");
+  }
+  const base = {
+    schemaVersion: CLI_EVENT_SCHEMA_VERSION,
+    kind: "run-event",
+    sequence,
+    type: event.type
+  };
+  switch (event.type) {
+    case "text-delta":
+      return { ...base, textDelta: event.textDelta };
+    case "tool-call":
+      return { ...base, toolCallId: event.toolCall.id, toolName: event.toolCall.name };
+    case "tool-result":
+      return {
+        ...base,
+        toolCallId: event.toolResult.toolCallId,
+        toolName: event.toolResult.toolName,
+        isError: event.toolResult.isError
+      };
+    case "tool-approval-request":
+    case "agent-approval-request":
+      return {
+        ...base,
+        approvalRequestId: event.approval.id,
+        approvalKind: event.approval.kind ?? "provider",
+        toolName: event.approval.name
+      };
+    case "agent-approval-resolved":
+      return {
+        ...base,
+        approvalRequestId: event.approval.approvalRequestId,
+        approved: event.approval.approve
+      };
+    case "provider-data":
+      return { ...base, provider: event.provider };
+    case "image-generation":
+      return {
+        ...base,
+        provider: event.provider,
+        partial: event.partial,
+        ...event.id ? { id: event.id } : {},
+        ...event.index !== undefined ? { index: event.index } : {}
+      };
+    case "finish":
+      return {
+        ...base,
+        ...event.finishReason ? { finishReason: event.finishReason } : {},
+        ...event.usage ? { usage: event.usage } : {}
+      };
+    case "error":
+      return { ...base, error: "Provider stream failed." };
+    case "agent-run-start":
+      return { ...base, currentStep: event.currentStep, maxSteps: event.maxSteps };
+    case "agent-step-start":
+      return { ...base, stepIndex: event.stepIndex };
+    case "agent-step-finish":
+      return {
+        ...base,
+        stepIndex: event.step.index,
+        status: event.step.status,
+        toolCalls: event.step.toolResults.length
+      };
+    case "agent-compaction":
+      return {
+        ...base,
+        compactionId: event.compaction.id,
+        reasons: event.compaction.reasons,
+        messageCountBefore: event.compaction.messageCountBefore,
+        messageCountAfter: event.compaction.messageCountAfter
+      };
+    case "agent-run-finish":
+      return {
+        ...base,
+        runId: event.state.runId,
+        status: event.status,
+        provider: event.state.provider,
+        model: event.state.modelId
+      };
+  }
+};
+var serializeStreamEvent = (event, sequence = 0) => JSON.stringify(streamEventDocument(event, sequence));
+var streamResultDocument = (result, sequence = 0) => {
+  if (!Number.isSafeInteger(sequence) || sequence < 0) {
+    throw new Error("JSONL result sequence must be a non-negative integer.");
+  }
+  return {
+    schemaVersion: CLI_EVENT_SCHEMA_VERSION,
+    kind: "run-stream-result",
+    sequence,
+    runId: result.runId,
+    status: result.status,
+    provider: result.provider,
+    model: result.model,
+    steps: result.steps,
+    toolCalls: result.toolCalls,
+    pendingApprovals: (result.pendingApprovals ?? []).map((approval) => ({
+      id: approval.id,
+      kind: approval.kind,
+      name: approval.name,
+      ...approval.childRunId ? { childRunId: approval.childRunId } : {},
+      ...approval.childAgentId ? { childAgentId: approval.childAgentId } : {}
+    })),
+    children: (result.children ?? []).map((child) => ({
+      runId: child.runId,
+      status: child.status
+    }))
+  };
+};
+var serializeStreamResult = (result, sequence = 0) => JSON.stringify(streamResultDocument(result, sequence));
+
+// src/client/protocol.ts
+import { z } from "zod";
+var HARNESS_CLIENT_PROTOCOL_VERSION = 1;
+var id = z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/);
+var revision = z.number().int().nonnegative().safe();
+var scoped = { projectId: id };
+var session = { ...scoped, sessionId: id };
+var run = { ...session, runId: id };
+var mutation = { idempotencyKey: id };
+var checkpoint = { ...session, checkpointId: z.string().uuid() };
+var restore = { ...session, operationId: z.string().uuid() };
+var fileDigest = z.string().regex(/^sha256:[a-f0-9]{64}$/);
+var harnessClientCommandSchema = z.discriminatedUnion("method", [
+  z.object({ method: z.literal("project.get"), ...scoped }).strict(),
+  z.object({ method: z.literal("policy.get"), ...scoped }).strict(),
+  z.object({ method: z.literal("session.list"), ...scoped, search: z.string().max(256).optional() }).strict(),
+  z.object({ method: z.literal("session.create"), ...scoped, ...mutation, title: z.string().max(256).optional() }).strict(),
+  z.object({ method: z.literal("session.get"), ...session }).strict(),
+  z.object({ method: z.literal("session.rename"), ...session, ...mutation, expectedRevision: revision, title: z.string().max(256) }).strict(),
+  z.object({ method: z.literal("checkpoint.list"), ...session }).strict(),
+  z.object({ method: z.literal("checkpoint.inspect"), ...checkpoint }).strict(),
+  z.object({
+    method: z.literal("checkpoint.capture"),
+    ...session,
+    ...mutation,
+    expectedRevision: revision,
+    turnId: id,
+    paths: z.array(z.string().min(1).max(1024)).min(1).max(20)
+  }).strict(),
+  z.object({
+    method: z.literal("restore.prepare"),
+    ...checkpoint,
+    ...mutation,
+    expectedRevision: revision,
+    expected: z.record(z.string().min(1).max(1024), fileDigest).refine((value) => Object.keys(value).length >= 1 && Object.keys(value).length <= 20)
+  }).strict(),
+  z.object({ method: z.literal("restore.get"), ...restore }).strict(),
+  z.object({ method: z.literal("restore.apply"), ...restore, ...mutation, expectedRevision: revision, reviewedProposalId: fileDigest }).strict(),
+  z.object({ method: z.literal("restore.recoverFork"), ...restore, ...mutation, expectedRevision: revision, forkSessionId: id }).strict(),
+  z.object({ method: z.literal("run.start"), ...session, ...mutation, expectedRevision: revision, prompt: z.string().min(1).max(64 * 1024) }).strict(),
+  z.object({ method: z.literal("run.get"), ...run, includeReview: z.boolean().optional(), includeDiff: z.boolean().optional(), decisionOffset: z.number().int().min(0).max(512).optional() }).strict(),
+  z.object({
+    method: z.literal("approval.resolve"),
+    ...run,
+    ...mutation,
+    expectedRevision: revision,
+    decisions: z.array(z.object({ approvalId: z.string().min(1).max(256), digest: z.string().regex(/^[a-f0-9]{64}$/), approve: z.boolean() }).strict()).min(1).max(64)
+  }).strict(),
+  z.object({ method: z.literal("run.cancel"), ...run, ...mutation, expectedRevision: revision }).strict()
+]);
+var harnessClientRequestSchema = z.object({
+  protocolVersion: z.literal(HARNESS_CLIENT_PROTOCOL_VERSION),
+  requestId: id,
+  connectionId: id,
+  command: harnessClientCommandSchema
+}).strict();
+
+export { CLI_JSON_SCHEMA_VERSION, CLI_EVENT_SCHEMA_VERSION, streamEventDocument, serializeStreamEvent, streamResultDocument, serializeStreamResult, HARNESS_CLIENT_PROTOCOL_VERSION, harnessClientCommandSchema, harnessClientRequestSchema };