@superdurable/connectors-sdk 0.1.1 → 0.3.0

package/dist/textgen/textgentest/index.js

@@ -0,0 +1,537 @@
+import {
+  goToBranch,
+  newQueryStep
+} from "../../chunk-NQQJS6OC.js";
+import "../../chunk-32YJXBE4.js";
+import {
+  createCall
+} from "../../chunk-QDMBAWXD.js";
+import "../../chunk-BQGYGCOQ.js";
+import "../../chunk-IHG6ADQG.js";
+
+// src/textgen/textgentest/fake_provider.ts
+import { createServer } from "http";
+var maxRecordedRequestBytes = 16 << 20;
+var redactedCredential = "[REDACTED]";
+var FakeProvider = class _FakeProvider {
+  #server;
+  #credentialHeader;
+  #credential;
+  #replies = [];
+  #requests = [];
+  constructor(credentialHeader, credential) {
+    this.#credentialHeader = credentialHeader;
+    this.#credential = credential;
+    this.#server = createServer(this.serveRequest.bind(this));
+  }
+  /** Start one fixture server; close it after the suite. */
+  static async start(credentialHeader, credential) {
+    if (!credentialHeader.name || !credential) throw new TypeError("textgentest fake provider needs a credential header and credential");
+    const provider = new _FakeProvider(credentialHeader, credential);
+    await new Promise((resolve) => provider.#server.listen(0, "127.0.0.1", resolve));
+    return provider;
+  }
+  /** Return the loopback base URL. */
+  baseURL() {
+    const address = this.#server.address();
+    if (!address || typeof address === "string") throw new Error("fake provider is closed");
+    return `http://127.0.0.1:${address.port}`;
+  }
+  /** Queue replies in request order. */
+  enqueueReplies(...replies) {
+    this.#replies.push(...replies);
+  }
+  /** Return a snapshot of sanitized requests. */
+  requests() {
+    return [...this.#requests];
+  }
+  /** Stop the fixture and all active connections. */
+  async close() {
+    this.#server.closeAllConnections();
+    await new Promise((resolve) => this.#server.close(() => resolve()));
+  }
+  async serveRequest(incoming, response) {
+    const chunks = [];
+    let byteCount = 0;
+    try {
+      for await (const chunk of incoming) {
+        const bytes = chunk;
+        byteCount += bytes.length;
+        if (byteCount > maxRecordedRequestBytes) {
+          response.writeHead(413);
+          response.end();
+          return;
+        }
+        chunks.push(bytes);
+      }
+    } catch {
+      return;
+    }
+    const body = Buffer.concat(chunks);
+    this.#requests.push(this.recordRequest(incoming, body));
+    const reply = this.#replies.shift();
+    if (!reply) {
+      response.writeHead(500, { "Content-Type": "application/json" });
+      response.end('{"error":{"type":"textgentest_no_scripted_reply"}}');
+      return;
+    }
+    if (!await this.waitForDelay(response, reply.delayMs ?? 0)) return;
+    if (reply.shouldDropConnection) {
+      response.destroy();
+      return;
+    }
+    response.writeHead(reply.statusCode ?? 200, reply.headers);
+    if (reply.body) response.write(reply.body);
+    for (const piece of reply.streamChunks ?? []) {
+      if (!await this.waitForDelay(response, piece.delayMs ?? 0)) return;
+      if (response.destroyed) return;
+      response.write(piece.data);
+    }
+    response.end();
+  }
+  recordRequest(incoming, body) {
+    const slotName = this.#credentialHeader.name.toLowerCase();
+    const expected = this.#credentialHeader.prefix + this.#credential;
+    const headers = {};
+    let hasCredentialOutsideSlot = (incoming.url ?? "").includes(this.#credential) || body.includes(this.#credential);
+    for (const [name, value] of Object.entries(incoming.headers)) {
+      const rendered = Array.isArray(value) ? value.join(",") : value ?? "";
+      if (name === slotName) continue;
+      if (rendered.includes(this.#credential)) hasCredentialOutsideSlot = true;
+      headers[name] = rendered.replaceAll(this.#credential, redactedCredential);
+    }
+    return {
+      method: incoming.method ?? "",
+      path: (incoming.url ?? "").replaceAll(this.#credential, redactedCredential),
+      headers,
+      body: Buffer.from(body.toString().replaceAll(this.#credential, redactedCredential)),
+      receivedAt: /* @__PURE__ */ new Date(),
+      hasCredentialInSlot: incoming.headers[slotName] === expected,
+      hasCredentialOutsideSlot
+    };
+  }
+  async waitForDelay(response, delayMs) {
+    if (delayMs <= 0) return !response.destroyed;
+    return new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        response.off("close", onClose);
+        resolve(!response.destroyed);
+      }, delayMs);
+      const onClose = () => {
+        clearTimeout(timer);
+        resolve(false);
+      };
+      response.once("close", onClose);
+    });
+  }
+};
+
+// src/textgen/textgentest/exchange_suite.ts
+import assert from "assert/strict";
+var credentialCanary = "sk-textgentest-credential-canary";
+var providerMessageCanary = "textgentest-private-provider-message";
+var generatedText = "The textgentest answer.";
+var partialText = "The partial textgentest";
+var reportedUsage = { inputTokens: 11, cachedInputTokens: 3, outputTokens: 7, reasoningTokens: 2, totalTokens: 18 };
+async function runTextGenerationExchangeSuite(suite) {
+  const dialect = suite?.dialect;
+  if (!dialect?.credentialHeader.name || !dialect.connectionModel || !dialect.alternateModel || !suite.newQuery) {
+    throw new TypeError("text generation exchange suite is incomplete");
+  }
+  const provider = await FakeProvider.start(dialect.credentialHeader, credentialCanary);
+  try {
+    const query = await suite.newQuery({ baseURL: provider.baseURL(), model: dialect.connectionModel, apiKey: credentialCanary, maxResponseBytes: 64 << 10 });
+    const completion = { text: generatedText, servedModel: "textgentest-served-model", responseId: "textgentest-response-1", usage: reportedUsage };
+    const basic = () => ({ messages: [{ role: "user", text: "Say hello to textgentest." }] });
+    const invoke = (request) => query.invoke(createCall({
+      flowId: "textgentest-flow",
+      stepExecutionId: "generate:1",
+      attempt: 1,
+      recordHeartbeat: async () => {
+      }
+    }, { provider: "textgentest", name: "default" }, query.definition().operation), request);
+    const assertSafeRequest = (request) => {
+      assert.equal(request.method, "POST");
+      assert.equal(request.hasCredentialInSlot, true);
+      assert.equal(request.hasCredentialOutsideSlot, false);
+      assert.equal(request.body.includes(credentialCanary), false);
+    };
+    provider.enqueueReplies(dialect.generatedReply(completion));
+    const generated = await invoke(basic());
+    assert.equal(generated.kind, "branch");
+    if (generated.kind !== "branch") throw new Error("generated reply retried");
+    assert.equal(generated.branch, "generated");
+    assert.equal(generated.value.text, generatedText);
+    assert.equal(generated.value.requestedModel, dialect.connectionModel);
+    assert.equal(generated.value.servedModel, completion.servedModel);
+    assert.equal(generated.value.responseId, completion.responseId);
+    assert.deepEqual(generated.value.usage, reportedUsage);
+    const firstRequest = provider.requests()[0];
+    assert.ok(firstRequest);
+    assertSafeRequest(firstRequest);
+    assert.equal(dialect.readRequestModel(firstRequest), dialect.connectionModel);
+    if (dialect.requestIDHeader) assert.ok(generated.receipt.providerRequestId);
+    for (const pointer of dialect.optionalRequestFieldPointers ?? []) assert.equal(resolveJSONPointer(firstRequest.body, pointer), void 0);
+    provider.enqueueReplies(dialect.generatedReply(completion));
+    const alternate = await invoke({ ...basic(), model: dialect.alternateModel });
+    assert.equal(alternate.kind, "branch");
+    if (alternate.kind === "branch") assert.equal(alternate.branch, "generated");
+    const secondRequest = provider.requests()[1];
+    assert.ok(secondRequest);
+    assertSafeRequest(secondRequest);
+    assert.equal(dialect.readRequestModel(secondRequest), dialect.alternateModel);
+    provider.enqueueReplies(dialect.truncatedReply({ ...completion, text: partialText }));
+    const truncated = await invoke(basic());
+    assert.equal(truncated.kind, "branch");
+    if (truncated.kind === "branch") {
+      assert.equal(truncated.branch, "truncated");
+      assert.equal(truncated.value.text, partialText);
+    }
+    provider.enqueueReplies(dialect.blockedReply(completion));
+    const blocked = await invoke(basic());
+    assert.equal(blocked.kind, "branch");
+    if (blocked.kind === "branch") {
+      assert.equal(blocked.branch, "blocked");
+      assert.equal(blocked.value.text, "");
+    }
+    for (const status of [429, 503]) {
+      provider.enqueueReplies(dialect.errorReply(status, providerMessageCanary));
+      const outcome = await invoke(basic());
+      assert.equal(outcome.kind, "retry");
+      if (outcome.kind === "retry") assert.equal(outcome.failure.kind, status === 429 ? "RATE_LIMIT" : "AVAILABILITY");
+      assert.equal(outcome.failure?.message.includes(providerMessageCanary), false);
+    }
+    provider.enqueueReplies(dialect.errorReply(401, providerMessageCanary));
+    const rejected = await invoke(basic());
+    assert.equal(rejected.kind, "branch");
+    if (rejected.kind === "branch") assert.equal(rejected.branch, "providerRejected");
+    provider.enqueueReplies(dialect.errorReply(403, providerMessageCanary));
+    const forbidden = await invoke(basic());
+    assert.equal(forbidden.kind, "branch");
+    if (forbidden.kind === "branch") {
+      assert.equal(forbidden.branch, "providerRejected");
+      assert.equal(forbidden.failure?.kind, "AUTHORIZATION");
+    }
+    provider.enqueueReplies(dialect.quotaExhaustedReply(providerMessageCanary));
+    const quota = await invoke(basic());
+    assert.equal(quota.kind, "branch");
+    if (quota.kind === "branch") {
+      assert.equal(quota.branch, "providerRejected");
+      assert.equal(quota.failure?.kind, "QUOTA_EXHAUSTED");
+    }
+    const retryWithSeconds = dialect.errorReply(429, providerMessageCanary);
+    provider.enqueueReplies({ ...retryWithSeconds, headers: { ...retryWithSeconds.headers, "Retry-After": "7" } });
+    const seconds = await invoke(basic());
+    assert.equal(seconds.kind, "retry");
+    if (seconds.kind === "retry") assert.equal(seconds.retryAfterMs, 7e3);
+    const retryWithDate = dialect.errorReply(429, providerMessageCanary);
+    provider.enqueueReplies({ ...retryWithDate, headers: {
+      ...retryWithDate.headers,
+      "Retry-After": new Date(Date.now() + 3e4).toUTCString()
+    } });
+    const dated = await invoke(basic());
+    assert.equal(dated.kind, "retry");
+    if (dated.kind === "retry") {
+      assert.ok(dated.retryAfterMs >= 25e3);
+      assert.ok(dated.retryAfterMs <= 3e4);
+    }
+    for (const status of [500, 502, 504]) {
+      provider.enqueueReplies(dialect.errorReply(status, providerMessageCanary));
+      const failure = await invoke(basic());
+      assert.equal(failure.kind, "retry");
+      if (failure.kind === "retry") assert.equal(failure.failure.kind, "AVAILABILITY");
+    }
+    provider.enqueueReplies({
+      statusCode: 503,
+      headers: { "Content-Type": "text/html" },
+      body: `<html>${providerMessageCanary}</html>`
+    });
+    const htmlGateway = await invoke(basic());
+    assert.equal(htmlGateway.kind, "retry");
+    assert.equal(htmlGateway.failure?.message.includes(providerMessageCanary), false);
+    const requestCountBeforeRedirect = provider.requests().length;
+    provider.enqueueReplies({ statusCode: 307, headers: { Location: `${provider.baseURL()}/redirected` } });
+    const redirect = await invoke(basic());
+    assert.equal(redirect.kind, "branch");
+    if (redirect.kind === "branch") assert.equal(redirect.branch, "invalidResponse");
+    assert.equal(provider.requests().length, requestCountBeforeRedirect + 1);
+    provider.enqueueReplies({ shouldDropConnection: true });
+    const dropped = await invoke(basic());
+    assert.equal(dropped.kind, "retry");
+    if (dropped.kind === "retry") assert.equal(dropped.failure.kind, "TRANSPORT");
+    provider.enqueueReplies(dialect.malformedReply());
+    const malformed = await invoke(basic());
+    assert.equal(malformed.kind, "branch");
+    if (malformed.kind === "branch") assert.equal(malformed.branch, "invalidResponse");
+    provider.enqueueReplies(dialect.generatedReply({ ...completion, text: "x".repeat(64 << 10) }));
+    const oversized = await invoke(basic());
+    assert.equal(oversized.kind, "branch");
+    if (oversized.kind === "branch") {
+      assert.equal(oversized.branch, "invalidResponse");
+      assert.equal(oversized.failure?.kind, "RESPONSE_TOO_LARGE");
+    }
+    if (query.requestFeatures().supportsStructuredOutput) {
+      const schema = { type: "object", additionalProperties: false, required: ["answer", "score"], properties: {
+        answer: { type: "string" },
+        score: { type: "integer", maximum: 10 }
+      } };
+      const structuredRequest = (selectedSchema) => ({
+        ...basic(),
+        structuredOutput: { name: "textgentest_answer", schema: selectedSchema }
+      });
+      const matching = '{"answer":"forty-two","score":7}';
+      provider.enqueueReplies(dialect.generatedReply({ ...completion, text: matching }));
+      const structured = await invoke(structuredRequest(schema));
+      assert.equal(structured.kind, "branch");
+      if (structured.kind === "branch") {
+        assert.equal(structured.branch, "generated", structured.failure?.message);
+        assert.equal(structured.value.text, matching);
+      }
+      provider.enqueueReplies(dialect.generatedReply({ ...completion, text: `\`\`\`json
+${matching}
+\`\`\`` }));
+      const fenced = await invoke(structuredRequest(schema));
+      assert.equal(fenced.kind, "branch");
+      if (fenced.kind === "branch") {
+        assert.equal(fenced.branch, "generated");
+        assert.equal(fenced.value.text, matching);
+      }
+      provider.enqueueReplies(dialect.generatedReply({ ...completion, text: '{"answer":"forty-two","score":42}' }));
+      const mismatched = await invoke(structuredRequest(schema));
+      assert.equal(mismatched.kind, "branch");
+      if (mismatched.kind === "branch") {
+        assert.equal(mismatched.branch, "invalidResponse");
+        assert.ok(mismatched.failure?.message.includes("/score"));
+      }
+      const invalidSchema = { ...schema, properties: {
+        ...schema.properties,
+        answer: { anyOf: [{ type: "string" }, { type: "integer" }] }
+      } };
+      const beforeInvalidSchema = provider.requests().length;
+      const invalid = await invoke(structuredRequest(invalidSchema));
+      assert.equal(invalid.kind, "branch");
+      if (invalid.kind === "branch") assert.equal(invalid.branch, "defect");
+      assert.equal(provider.requests().length, beforeInvalidSchema);
+    }
+    const invalidModelRequest = { ...basic(), model: "invalid model id" };
+    const countBeforeInvalidModel = provider.requests().length;
+    const invalidModel = await invoke(invalidModelRequest);
+    assert.equal(invalidModel.kind, "branch");
+    if (invalidModel.kind === "branch") assert.equal(invalidModel.branch, "defect");
+    assert.equal(provider.requests().length, countBeforeInvalidModel);
+    if (dialect.reportedErrorReply) {
+      provider.enqueueReplies(dialect.reportedErrorReply("textgentest_unmatched_error", providerMessageCanary));
+      const reported = await invoke(basic());
+      assert.equal(reported.kind, "branch");
+      if (reported.kind === "branch") assert.equal(reported.branch, "invalidResponse");
+      assert.equal(reported.failure?.message.includes(providerMessageCanary), false);
+    }
+    if (dialect.interruptedStreamReply) {
+      provider.enqueueReplies(dialect.interruptedStreamReply(completion));
+      const interrupted = await invoke(basic());
+      assert.equal(interrupted.kind, "retry");
+      if (interrupted.kind === "retry") assert.equal(interrupted.failure.kind, "TRANSPORT");
+    }
+    if (dialect.unstreamedReply) {
+      provider.enqueueReplies(dialect.unstreamedReply(completion));
+      const unstreamed = await invoke(basic());
+      assert.equal(unstreamed.kind, "branch");
+      if (unstreamed.kind === "branch") assert.equal(unstreamed.branch, "generated");
+    }
+    for (const rejectedRequest of suite.locallyRejectedRequests ?? []) {
+      const before = provider.requests().length;
+      const local = await invoke(rejectedRequest);
+      assert.equal(local.kind, "branch");
+      if (local.kind === "branch") assert.equal(local.branch, "defect");
+      assert.equal(provider.requests().length, before);
+    }
+  } finally {
+    await provider.close();
+  }
+}
+function resolveJSONPointer(body, pointer) {
+  if (!pointer.startsWith("/")) throw new TypeError("optional request pointer must begin with /");
+  let value = JSON.parse(body.toString());
+  for (const encoded of pointer.slice(1).split("/")) {
+    const segment = encoded.replaceAll("~1", "/").replaceAll("~0", "~");
+    if (value === null || typeof value !== "object") return void 0;
+    value = value[segment];
+  }
+  return value;
+}
+
+// src/textgen/textgentest/dex_scenarios.ts
+import assert2 from "assert/strict";
+import { randomUUID } from "crypto";
+import { mkdtemp, rm } from "fs/promises";
+import { tmpdir } from "os";
+import { join } from "path";
+import {
+  Client,
+  Registry,
+  StepList,
+  Stream,
+  Worker,
+  forceComplete,
+  openBlobCache,
+  stringCodec
+} from "@superdurable/dex";
+var CompleteTextGeneration = class {
+  constructor(stepType) {
+    this.stepType = stepType;
+  }
+  stepType;
+  getStepType() {
+    return this.stepType;
+  }
+  execute(_context, result) {
+    return forceComplete(result);
+  }
+};
+async function runTextGenerationDexScenarios(suite) {
+  if (!suite?.dialect || !suite.newQuery) throw new TypeError("text generation Dex scenario suite is incomplete");
+  const credential = "sk-textgentest-dex-canary";
+  const provider = await FakeProvider.start(suite.dialect.credentialHeader, credential);
+  const cacheDirectory = await mkdtemp(join(tmpdir(), "textgentest-dex-"));
+  const cache = openBlobCache({ directory: cacheDirectory, maxBytes: 64 << 20 });
+  let client;
+  let worker;
+  try {
+    const query = await suite.newQuery({
+      baseURL: provider.baseURL(),
+      model: suite.dialect.connectionModel,
+      apiKey: credential,
+      maxResponseBytes: 64 << 10,
+      requestTimeoutMs: 15e3
+    });
+    const unique = randomUUID().replaceAll("-", "");
+    const textStream = new Stream(`textgentest-text-${unique}`, stringCodec, 1 << 20);
+    const done = new CompleteTextGeneration(`TextgentestDone${unique}`);
+    const step = newQueryStep({
+      stepType: `TextgentestGenerate${unique}`,
+      annotations: { groupId: "textgentest", groupLabel: "Text Generation Test", explanation: "Generate a fixture answer." },
+      connection: { provider: "textgentest", name: "default" },
+      mapToOperationInput: (input2) => input2,
+      operation: query,
+      branches: [goToBranch("generated", done)],
+      textStream,
+      stepOptionsOverride: {
+        executeDurability: "sync",
+        executeMethodTimeoutMs: 2e4,
+        heartbeatTimeoutMs: 1e4,
+        executeRetry: {
+          initialIntervalMs: 1e3,
+          backoffCoefficient: 1,
+          maximumIntervalMs: 1e3,
+          maximumAttempts: 3,
+          totalDurationMs: 3e4
+        }
+      }
+    });
+    const flow = {
+      getFlowType: () => `TextgentestFlow${unique}`,
+      getSteps: () => StepList.startStep(step).otherSteps(done),
+      getPersistenceSchema: () => ({ streams: [textStream] })
+    };
+    const registry = new Registry([flow]);
+    const serverAddress = suite.serverAddress ?? process.env.DEX_SERVER_ADDRESS ?? "127.0.0.1:18891";
+    const workerOptions = { serverAddress, pull: { maxConcurrentTasks: 4, reservedRpcTasks: 0, stopDrainTimeoutMs: 100 } };
+    worker = new Worker(registry, cache, workerOptions);
+    client = new Client(registry, cache, { serverAddress });
+    await worker.start();
+    await worker.waitPullRegistered({ timeoutMs: 1e4 });
+    const completion = {
+      text: "The textgentest Dex answer.",
+      servedModel: "textgentest-served",
+      responseId: "textgentest-dex-1",
+      usage: { inputTokens: 11, cachedInputTokens: 3, outputTokens: 7, reasoningTokens: 2, totalTokens: 18 }
+    };
+    provider.enqueueReplies(suite.dialect.errorReply(429, "private retry message"), {
+      ...suite.dialect.generatedReply(completion),
+      delayMs: 11e3
+    });
+    const firstFlowID = `textgentest-${randomUUID()}`;
+    const input = { model: suite.dialect.alternateModel, messages: [{ role: "user", text: "Say hello." }] };
+    await client.startFlow(flow, firstFlowID, input);
+    const generated = await client.waitForFlow(firstFlowID, 35e3);
+    assert2.equal(generated.status, "completed", generated.errorMessage ?? "text generation did not complete");
+    const generatedResult = generated.singleOutput().value;
+    assert2.equal(generatedResult.text, completion.text);
+    assert2.equal(generatedResult.requestedModel, suite.dialect.alternateModel);
+    assert2.equal(provider.requests().length, 2);
+    const firstRequest = provider.requests()[0];
+    const secondRequest = provider.requests()[1];
+    assert2.ok(firstRequest && secondRequest);
+    assert2.equal(suite.dialect.readRequestModel(firstRequest), suite.dialect.alternateModel);
+    assert2.equal(suite.dialect.readRequestModel(secondRequest), suite.dialect.alternateModel);
+    assert2.equal(firstRequest.hasCredentialInSlot && secondRequest.hasCredentialInSlot, true);
+    const textMessages = await waitForTextMessages(client, firstFlowID, textStream);
+    assert2.ok(textMessages.some((message) => message.includes(completion.text)));
+    provider.enqueueReplies(suite.dialect.truncatedReply({ ...completion, text: "partial" }));
+    const secondFlowID = `textgentest-${randomUUID()}`;
+    await client.startFlow(flow, secondFlowID, { messages: [{ role: "user", text: "Continue." }] });
+    const truncated = await client.waitForFlow(secondFlowID, 1e4);
+    assert2.equal(truncated.status, "failed");
+    assert2.equal(provider.requests().length, 3);
+    let expectedRequestsBeforeWorkerLoss = 3;
+    if (suite.dialect.interruptedStreamReply) {
+      const partial = "partial from interrupted attempt";
+      provider.enqueueReplies(
+        suite.dialect.interruptedStreamReply({ ...completion, text: partial }),
+        suite.dialect.generatedReply(completion)
+      );
+      const interruptedFlowID = `textgentest-${randomUUID()}`;
+      await client.startFlow(flow, interruptedFlowID, { messages: [{ role: "user", text: "Retry the stream." }] });
+      const completedAfterRetry = await client.waitForFlow(interruptedFlowID, 15e3);
+      assert2.equal(completedAfterRetry.status, "completed");
+      assert2.equal(completedAfterRetry.singleOutput().value.text, completion.text);
+      const text = await waitForTextMessages(client, interruptedFlowID, textStream, 2);
+      assert2.equal(text.reverse().join(""), partial + completion.text);
+      expectedRequestsBeforeWorkerLoss += 2;
+      assert2.equal(provider.requests().length, expectedRequestsBeforeWorkerLoss);
+    }
+    provider.enqueueReplies(
+      { ...suite.dialect.generatedReply(completion), delayMs: 6e4 },
+      suite.dialect.generatedReply(completion)
+    );
+    const lostWorkerFlowID = `textgentest-${randomUUID()}`;
+    await client.startFlow(flow, lostWorkerFlowID, { messages: [{ role: "user", text: "Recover." }] });
+    await waitForRecordedRequests(provider, expectedRequestsBeforeWorkerLoss + 1);
+    await worker.close();
+    worker = new Worker(registry, cache, workerOptions);
+    await worker.start();
+    await worker.waitPullRegistered({ timeoutMs: 1e4 });
+    const recovered = await client.waitForFlow(lostWorkerFlowID, 35e3);
+    assert2.equal(recovered.status, "completed", recovered.errorMessage ?? "lost Worker request did not recover");
+    assert2.equal(recovered.singleOutput().value.text, completion.text);
+    assert2.equal(provider.requests().length, expectedRequestsBeforeWorkerLoss + 2);
+  } finally {
+    if (client) await client.close();
+    if (worker) await worker.close();
+    cache.close();
+    await rm(cacheDirectory, { recursive: true, force: true });
+    await provider.close();
+  }
+}
+async function waitForRecordedRequests(provider, count) {
+  const deadline = Date.now() + 1e4;
+  while (Date.now() < deadline) {
+    if (provider.requests().length >= count) return;
+    await new Promise((resolve) => setTimeout(resolve, 50));
+  }
+  throw new Error("fake provider did not receive the expected request");
+}
+async function waitForTextMessages(client, flowID, stream, expectedCount = 1) {
+  const deadline = Date.now() + 5e3;
+  while (Date.now() < deadline) {
+    const page = await client.listStreamMessages(flowID, stream, 10);
+    if (page.messages.length >= expectedCount) return page.messages.map((message) => message.value);
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  throw new Error("text generation Stream did not converge");
+}
+export {
+  FakeProvider,
+  runTextGenerationDexScenarios,
+  runTextGenerationExchangeSuite
+};

package/dist/{credentials-vrvW0d4j.d.ts → types-D6De3sry.d.ts}

@@ -1,5 +1,4 @@
 import { z } from 'zod';
-import { AsyncContext, Stream, BufferedTextStreamOptions } from '@superdurable/dex';
 
 /** Provider or local fact independent of retry policy. */
 declare const FailureKindSchema: z.ZodEnum<{
@@ -344,102 +343,4 @@ declare const ConnectorConfigurationRefSchema: z.ZodObject<{
 /** Stable Flow and Step configuration owner. */
 type ConnectorConfigurationRef = z.infer<typeof ConnectorConfigurationRefSchema>;
 
-/** Provider-safe progress before Dex identity and sequence are added. */
-interface Progress {
-    /** Provider-specific stable phase. */ phase: string;
-    /** Optional safe progress text. */ message?: string;
-    /** Optional inclusive fraction from zero to one. */ percent?: number;
-    /** Optional provider-owned monotonic sequence. */ providerSequence?: number;
-}
-/** Structured best-effort Dex Stream message. */
-interface ProgressUpdate extends Progress {
-    /** Stable connector call ID. */ callId: CallID;
-    /** One-based Dex Execute attempt. */ attempt: number;
-    /** Connector-assigned monotonic sequence within this attempt. */ sequence: number;
-}
-/** Optional application-owned Streams for one connector invocation. */
-interface CallProgressOptions {
-    /** Registered structured progress Stream. */ progressStream?: Stream<ProgressUpdate>;
-    /** Registered string Stream for ordered buffered text. */ textStream?: Stream<string>;
-    /** Flush interval and soft UTF-8 batch limit for text. */ textOptions?: BufferedTextStreamOptions;
-}
-/** Provider-safe call metadata with its live, non-serializable Dex Step context. */
-interface Call {
-    /** Active Dex Execute context; Step factories attach it as a non-enumerable field. */ context: AsyncContext;
-    /** Stable identity across retries. */ id: CallID;
-    /** Provider deduplication key, when available. */ idempotencyKey?: string;
-    /** Logical named connection. */ connection: ConnectionRef;
-    /** Manifest operation identity. */ operation: OperationRef;
-    /** Append structured progress when a Stream is configured. */ reportProgress(progress: Progress): void;
-    /** Append text in order when a buffered Stream is configured. */ writeText(value: string): void;
-    /** Whether structured progress output is configured. */ hasProgressStream(): boolean;
-    /** Whether buffered text output is configured. */ hasTextStream(): boolean;
-}
-/** Bind a live Dex Execute context to a stable, provider-safe call identity. */
-declare function createCall(context: AsyncContext, connection: ConnectionRef, operation: OperationRef, options?: CallProgressOptions): Call;
-/** Resolve a credential at call time outside durable Flow state. */
-interface CredentialProvider<C> {
-    /** Return current credentials, honoring cancellation. */
-    resolve(call: Call, signal?: AbortSignal): Promise<C>;
-}
-/** Resolve credentials outside a Dex Step, such as for a Trigger source. */
-interface ContextCredentialProvider<C> extends CredentialProvider<C> {
-    /** Return current credentials under an explicit cancellation signal. */
-    resolveContext(call: Call, signal: AbortSignal): Promise<C>;
-}
-/** Current private material and decision time for a refresh driver. */
-interface CredentialRefreshState<C> {
-    /** Current connector-specific credential. */ credentials: C;
-    /** Known access credential expiry. */ expiresAt?: Date;
-    /** Captured decision time. */ now: Date;
-}
-/** Complete replacement credential and mandatory access expiry. */
-interface CredentialRefreshResult<C> {
-    /** Complete replacement, retaining omitted renewal material. */ credentials: C;
-    /** Replacement access expiry. */ expiresAt: Date;
-}
-/** Connector-specific provider refresh contract; persistence belongs to the host. */
-interface CredentialRefreshDriver<C> {
-    /** Decide deterministically whether a credential needs provider renewal. */
-    refreshRequired(state: CredentialRefreshState<C>): boolean;
-    /** Make one provider refresh request after the host admits it durably. */
-    refresh(state: CredentialRefreshState<C>, signal: AbortSignal): Promise<CredentialRefreshResult<C>>;
-}
-/** Host adapter that refreshes and persists a connection atomically. */
-interface RefreshingCredentialProvider<C> extends CredentialProvider<C> {
-    /** Serialize refresh for one connection, reload state, and persist replacement. */
-    resolveWithRefresh(call: Call, driver: CredentialRefreshDriver<C>, signal?: AbortSignal): Promise<C>;
-}
-/** Host adapter for one explicit provider authentication rejection. */
-interface RejectedCredentialRefreshingProvider<C> {
-    /** Force one coordinated refresh after the provider rejects an access token. */
-    resolveAfterRejection(call: Call, driver: CredentialRefreshDriver<C>, signal?: AbortSignal): Promise<C>;
-}
-/** Resolve through host refresh support, then context-aware or ordinary lookup. */
-declare function resolveCredential<C>(provider: CredentialProvider<C>, call: Call, driver: CredentialRefreshDriver<C>, signal?: AbortSignal): Promise<C>;
-/** Force one coordinated refresh after a provider authentication rejection. */
-declare function resolveCredentialAfterRejection<C>(provider: CredentialProvider<C>, call: Call, driver: CredentialRefreshDriver<C>, signal?: AbortSignal): Promise<C>;
-/** In-memory named credentials for examples and tests; never persisted by this class. */
-declare class StaticCredentialProvider<C> implements RefreshingCredentialProvider<C> {
-    #private;
-    /** Capture all connection values during construction. */
-    constructor(entries: Iterable<readonly [ConnectionRef, C]>);
-    /** Return the configured credential or reject a missing connection. */
-    resolve(call: Call): Promise<C>;
-    /** Static credentials never expire and therefore do not call the driver. */
-    resolveWithRefresh(call: Call): Promise<C>;
-}
-/** Wrap a secret that cannot be serialized or printed. */
-declare class SecretString {
-    #private;
-    /** Hold one private value outside default stringification and inspection. */
-    constructor(value: string);
-    /** Reveal only at the provider request boundary. */
-    reveal(): string;
-    /** Return a fixed redaction for accidental string formatting. */
-    toString(): string;
-    /** Reject accidental JSON persistence. */
-    toJSON(): never;
-}
-
-export { StaticCredentialProvider as $, type MutationDefinitionWire as A, type BranchID as B, type Call as C, DefectBranchID as D, MutationDefinitionWireSchema as E, type Failure as F, MutationResultSchema as G, OperationRefSchema as H, type IdempotencyKey as I, type Progress as J, type QueryDefinitionWire as K, QueryDefinitionWireSchema as L, type MutationAttempt as M, QueryResultSchema as N, type OperationRef as O, type ProgressUpdate as P, type QueryAttempt as Q, ReauthorizationRequiredError as R, type Receipt as S, type ReceiptDraft as T, UncertainBranchID as U, ReceiptSchema as V, type RefreshingCredentialProvider as W, type RejectedCredentialRefreshingProvider as X, RetryError as Y, type RetryPolicy as Z, SecretString as _, type CallID as a, type StepDefaultsWire as a0, StepDefaultsWireSchema as a1, createCall as a2, defaultConnectorStepExecuteRetryPolicy as a3, defaultIdempotencyKey as a4, deriveCallID as a5, newMutationBranch as a6, newMutationRetry as a7, newMutationUncertain as a8, newQueryBranch as a9, newQueryRetry as aa, resolveCredential as ab, resolveCredentialAfterRejection as ac, retryPolicyToGoWire as ad, zeroReceipt as ae, type MutationResult as b, type QueryResult as c, type ConnectorConfigurationUI as d, type ConnectionRef as e, type BranchDefinition as f, BranchDefinitionSchema as g, CallIDNamespace as h, CallIDSchema as i, type CallProgressOptions as j, ConnectionRefSchema as k, type ConnectorConfigurationRef as l, ConnectorConfigurationRefSchema as m, ConnectorConfigurationUISchema as n, type ConnectorUIBinding as o, ConnectorUIBindingSchema as p, type ConnectorUIUnit as q, ConnectorUIUnitSchema as r, type ContextCredentialProvider as s, type CredentialProvider as t, type CredentialRefreshDriver as u, type CredentialRefreshResult as v, type CredentialRefreshState as w, type FailureKind as x, FailureKindSchema as y, FailureSchema as z };
+export { type Receipt as A, type BranchID as B, type CallID as C, DefectBranchID as D, type ReceiptDraft as E, type Failure as F, ReceiptSchema as G, RetryError as H, type IdempotencyKey as I, type RetryPolicy as J, StepDefaultsWireSchema as K, defaultConnectorStepExecuteRetryPolicy as L, type MutationAttempt as M, defaultIdempotencyKey as N, type OperationRef as O, deriveCallID as P, type QueryAttempt as Q, ReauthorizationRequiredError as R, type StepDefaultsWire as S, newMutationBranch as T, UncertainBranchID as U, newMutationRetry as V, newMutationUncertain as W, newQueryBranch as X, newQueryRetry as Y, retryPolicyToGoWire as Z, zeroReceipt as _, type MutationResult as a, type QueryResult as b, type ConnectorConfigurationUI as c, type ConnectionRef as d, type BranchDefinition as e, BranchDefinitionSchema as f, CallIDNamespace as g, CallIDSchema as h, ConnectionRefSchema as i, type ConnectorConfigurationRef as j, ConnectorConfigurationRefSchema as k, ConnectorConfigurationUISchema as l, type ConnectorUIBinding as m, ConnectorUIBindingSchema as n, type ConnectorUIUnit as o, ConnectorUIUnitSchema as p, type FailureKind as q, FailureKindSchema as r, FailureSchema as s, type MutationDefinitionWire as t, MutationDefinitionWireSchema as u, MutationResultSchema as v, OperationRefSchema as w, type QueryDefinitionWire as x, QueryDefinitionWireSchema as y, QueryResultSchema as z };