@lostgradient/weft 0.2.0

package/dist/server/operations/resume-schedule.d.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+import type { UnknownRestBinding } from '../rest-bindings.ts';
+declare const resumeScheduleInput: z.ZodObject<{
+    scheduleId: z.ZodString;
+}, z.core.$strip>;
+declare const resumeScheduleOutput: z.ZodUndefined;
+export type ResumeScheduleInput = z.infer<typeof resumeScheduleInput>;
+export type ResumeScheduleOutput = z.infer<typeof resumeScheduleOutput>;
+export declare const resumeScheduleOperation: import("../operation-catalog.ts").OperationDefinition<{
+    scheduleId: string;
+}, undefined>;
+export declare const resumeScheduleRestBinding: UnknownRestBinding;
+export {};

package/dist/server/operations/resume-schedule.js

@@ -0,0 +1,43 @@
+import { z } from "zod";
+import { defineOperation } from "../operation-registry.js";
+import { shapeRestFault } from "./operation-helpers.js";
+import { mapScheduleErrorToFault } from "./schedule-faults.js";
+const resumeScheduleInput = z.object({
+  scheduleId: z.string().min(1)
+}), resumeScheduleOutput = z.undefined();
+export const resumeScheduleOperation = defineOperation({
+  name: "weft.schedules.resume",
+  mcpExposable: !1,
+  summary: "Resume a recurring schedule",
+  description: "Resume a paused recurring schedule by `scheduleId` so it begins launching workflows on its cadence again. Faults with NotFound when no schedule with the given id exists.",
+  destructive: !1,
+  tags: ["Schedules"],
+  inputSchema: resumeScheduleInput,
+  outputSchema: resumeScheduleOutput,
+  access: { kind: "public" },
+  producibleFaults: ["NotFound", "Conflict"],
+  transports: { http: !0, jsonRpcHttp: !0, jsonRpcWebSocket: !0, jsonRpcStdio: !0 },
+  unknownKeyPolicy: { http: "strip", jsonRpc: "reject" },
+  invoke: async ({ input, engine }) => {
+    const typedEngine = engine;
+    try {
+      await typedEngine.resumeSchedule(input.scheduleId);
+      return;
+    } catch (error) {
+      throw mapScheduleErrorToFault(input.scheduleId, error);
+    }
+  }
+}), resumeScheduleRestBinding = {
+  method: "POST",
+  path: "/v1/schedules/:id/resume",
+  pathParamNames: ["id"],
+  operationName: "weft.schedules.resume",
+  inputSources: {
+    scheduleId: { kind: "path", pathParam: "id" }
+  },
+  extractInput: async (_request, pathParams) => ({
+    scheduleId: pathParams.id ?? ""
+  }),
+  success: { kind: "empty", status: 204 },
+  shapeFault: shapeRestFault
+};

package/dist/server/operations/resume-workflow.d.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import type { UnknownRestBinding } from '../rest-bindings.ts';
+declare const resumeWorkflowInput: z.ZodObject<{
+    workflowId: z.ZodString;
+}, z.core.$strip>;
+declare const resumeWorkflowOutput: z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$strip>;
+export type ResumeWorkflowInput = z.infer<typeof resumeWorkflowInput>;
+export type ResumeWorkflowOutput = z.infer<typeof resumeWorkflowOutput>;
+export declare const resumeWorkflowOperation: import("../operation-catalog.ts").OperationDefinition<{
+    workflowId: string;
+}, {
+    id: string;
+}>;
+export declare const resumeWorkflowRestBinding: UnknownRestBinding;
+export {};

package/dist/server/operations/resume-workflow.js

@@ -0,0 +1,40 @@
+import { z } from "zod";
+import { shapeRestFault } from "./operation-helpers.js";
+import {
+  createSingleWorkflowControlOperation,
+  extractWorkflowIdFromPath
+} from "./single-workflow-control-operation.js";
+const resumeWorkflowInput = z.object({
+  workflowId: z.string().min(1)
+}), resumeWorkflowOutput = z.object({
+  id: z.string()
+});
+export const resumeWorkflowOperation = createSingleWorkflowControlOperation({
+  name: "weft.workflows.resume",
+  summary: "Resume a suspended workflow",
+  description: "Resume a workflow that is suspended (for example, paused awaiting a human review or an operator hold) by `workflowId`, returning the workflow `id`. Faults with NotFound when the workflow is not visible.",
+  destructive: !1,
+  tags: ["Workflows"],
+  inputSchema: resumeWorkflowInput,
+  outputSchema: resumeWorkflowOutput,
+  producibleFaults: ["NotFound", "Conflict"],
+  invoke: async ({ input, engine }) => {
+    return { id: (await engine.resume(input.workflowId)).id };
+  },
+  mapErrorToFault: ({ message }) => message.includes("Cannot resume") ? {
+    code: "Conflict",
+    message,
+    data: { reason: message }
+  } : void 0
+}), resumeWorkflowRestBinding = {
+  method: "POST",
+  path: "/v1/workflows/:id/resume",
+  pathParamNames: ["id"],
+  operationName: "weft.workflows.resume",
+  inputSources: {
+    workflowId: { kind: "path", pathParam: "id" }
+  },
+  extractInput: async (_request, pathParams) => extractWorkflowIdFromPath(pathParams),
+  success: { kind: "json", status: 200 },
+  shapeFault: shapeRestFault
+};

package/dist/server/operations/schedule-faults.d.ts

@@ -0,0 +1,14 @@
+import type { ScheduleSpec } from '../../core/types.ts';
+import type { OperationFault } from '../operation-fault.ts';
+export { isOperationFault } from './operation-helpers.ts';
+export declare function mapScheduleErrorToFault(scheduleId: string, error: unknown): OperationFault;
+/**
+ * Validate the mutually exclusive schedule cadence fields (`cronExpression` or
+ * `every`) present on both create and update inputs. Exactly one must be
+ * supplied. Throws an `InvalidParams` fault on the first validation failure so
+ * REST and JSON-RPC callers receive identical error messages.
+ */
+export declare function validateScheduleInputCadence(input: {
+    cronExpression?: unknown;
+    every?: unknown;
+}): ScheduleSpec;

package/dist/server/operations/schedule-faults.js

@@ -0,0 +1,41 @@
+import { invalidParamsFault } from "./operation-helpers.js";
+export { isOperationFault } from "./operation-helpers.js";
+export function mapScheduleErrorToFault(scheduleId, error) {
+  const message = error instanceof Error ? error.message : String(error), normalizedMessage = message.toLowerCase();
+  if (normalizedMessage.includes("not found"))
+    return {
+      code: "NotFound",
+      message,
+      data: { resource: "schedule", identifier: scheduleId }
+    };
+  if (normalizedMessage.includes("already exists") || normalizedMessage.includes("cannot be resumed"))
+    return {
+      code: "Conflict",
+      message,
+      data: { reason: message }
+    };
+  if (message.includes("Missing required field") || normalizedMessage.includes("must be") || normalizedMessage.includes("no workflow registered") || normalizedMessage.includes("cron") || normalizedMessage.includes("interval"))
+    return {
+      code: "InvalidParams",
+      message,
+      data: { issues: [] }
+    };
+  return {
+    code: "EngineFailure",
+    message,
+    data: {}
+  };
+}
+export function validateScheduleInputCadence(input) {
+  const hasCron = input.cronExpression !== void 0, hasEvery = input.every !== void 0;
+  if (hasCron && hasEvery)
+    throw invalidParamsFault("Provide exactly one of cronExpression or every, not both");
+  if (hasEvery) {
+    if (typeof input.every !== "string" && typeof input.every !== "number")
+      throw invalidParamsFault('Field "every" must be a duration string or a number of milliseconds');
+    return { every: input.every };
+  }
+  if (typeof input.cronExpression !== "string" || input.cronExpression.length === 0)
+    throw invalidParamsFault("Missing required field: cronExpression or every");
+  return { cron: input.cronExpression };
+}

package/dist/server/operations/set-workflow-attributes.d.ts

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+import type { UnknownRestBinding } from '../rest-bindings.ts';
+declare const setWorkflowAttributesInput: z.ZodObject<{
+    workflowId: z.ZodString;
+    attributes: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>;
+declare const setWorkflowAttributesOutput: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+}, z.core.$strip>;
+export type SetWorkflowAttributesInput = z.infer<typeof setWorkflowAttributesInput>;
+export type SetWorkflowAttributesOutput = z.infer<typeof setWorkflowAttributesOutput>;
+export declare const setWorkflowAttributesOperation: import("../operation-catalog.ts").OperationDefinition<{
+    workflowId: string;
+    attributes?: unknown;
+}, {
+    ok: true;
+}>;
+export declare const setWorkflowAttributesRestBinding: UnknownRestBinding;
+export {};

package/dist/server/operations/set-workflow-attributes.js

@@ -0,0 +1,67 @@
+import { z } from "zod";
+import { defineOperation } from "../operation-registry.js";
+import { shapeRestFault } from "./operation-helpers.js";
+const setWorkflowAttributesInput = z.object({
+  workflowId: z.string().min(1),
+  attributes: z.unknown().optional()
+}), setWorkflowAttributesOutput = z.object({
+  ok: z.literal(!0)
+});
+export const setWorkflowAttributesOperation = defineOperation({
+  name: "weft.workflows.attributes.set",
+  mcpExposable: !1,
+  summary: "Update search attributes for a workflow",
+  destructive: !1,
+  tags: ["Attributes"],
+  inputSchema: setWorkflowAttributesInput,
+  outputSchema: setWorkflowAttributesOutput,
+  access: { kind: "public" },
+  transports: { http: !0, jsonRpcHttp: !0, jsonRpcWebSocket: !0, jsonRpcStdio: !0 },
+  unknownKeyPolicy: { http: "strip", jsonRpc: "reject" },
+  invoke: async ({ input, engine }) => {
+    const e = engine;
+    try {
+      await e.setAttributes(input.workflowId, input.attributes ?? {});
+      return { ok: !0 };
+    } catch (error) {
+      throw {
+        code: "EngineFailure",
+        message: error instanceof Error ? error.message : String(error),
+        data: {}
+      };
+    }
+  }
+});
+function shapeSetWorkflowAttributesSuccess(output) {
+  return new Response(JSON.stringify(output), {
+    status: 200,
+    headers: { "Content-Type": "application/json" }
+  });
+}
+function shapeSetWorkflowAttributesFault(fault) {
+  return shapeRestFault(fault);
+}
+export const setWorkflowAttributesRestBinding = {
+  method: "PATCH",
+  path: "/v1/workflows/:id/attributes",
+  pathParamNames: ["id"],
+  operationName: "weft.workflows.attributes.set",
+  inputSources: {
+    workflowId: { kind: "path", pathParam: "id" },
+    attributes: { kind: "body-field", bodyField: "attributes" }
+  },
+  extractInput: async (request, pathParams) => {
+    const body = await request.json().catch(() => {
+      throw Error("Invalid JSON body");
+    });
+    if (body === null)
+      throw Error("Invalid JSON body");
+    return {
+      workflowId: pathParams.id ?? "",
+      attributes: typeof body === "object" ? body.attributes : void 0
+    };
+  },
+  success: { kind: "json", status: 200 },
+  shapeSuccess: (output) => shapeSetWorkflowAttributesSuccess(output),
+  shapeFault: shapeSetWorkflowAttributesFault
+};

package/dist/server/operations/signal-workflow.d.ts

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+import type { UnknownRestBinding } from '../rest-bindings.ts';
+declare const signalWorkflowInput: z.ZodObject<{
+    workflowId: z.ZodString;
+    signalName: z.ZodString;
+    payload: z.ZodOptional<z.ZodUnknown>;
+    signalId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const signalWorkflowOutput: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+}, z.core.$strip>;
+export type SignalWorkflowInput = z.infer<typeof signalWorkflowInput>;
+export type SignalWorkflowOutput = z.infer<typeof signalWorkflowOutput>;
+export declare const signalWorkflowOperation: import("../operation-catalog.ts").OperationDefinition<{
+    workflowId: string;
+    signalName: string;
+    payload?: unknown;
+    signalId?: string | undefined;
+}, {
+    ok: true;
+}>;
+export declare const signalWorkflowRestBinding: UnknownRestBinding;
+export {};

package/dist/server/operations/signal-workflow.js

@@ -0,0 +1,58 @@
+import { z } from "zod";
+import { isSignalIdWithinByteLimit } from "../../core/signal-id.js";
+import { shapeRestFault } from "./operation-helpers.js";
+import {
+  createSingleWorkflowControlOperation,
+  extractWorkflowIdFromPath
+} from "./single-workflow-control-operation.js";
+const signalWorkflowInput = z.object({
+  workflowId: z.string().min(1),
+  signalName: z.string().min(1),
+  payload: z.unknown().optional(),
+  signalId: z.string().min(1).refine(isSignalIdWithinByteLimit, "signalId must be at most 128 bytes").optional()
+}), signalWorkflowOutput = z.object({
+  ok: z.literal(!0)
+});
+export const signalWorkflowOperation = createSingleWorkflowControlOperation({
+  name: "weft.workflows.signal",
+  summary: "Send a signal to a workflow",
+  description: "Deliver a named signal with an optional payload to a running workflow. Requires the workflow `id` and the signal `name`; `payload` is optional. Signals are fire-and-forget from the caller perspective and do not return a handler result. Faults with NotFound when the workflow is not visible and InvalidParams when the payload exceeds the size limit.",
+  destructive: !0,
+  tags: ["Signals"],
+  inputSchema: signalWorkflowInput,
+  outputSchema: signalWorkflowOutput,
+  producibleFaults: ["NotFound"],
+  invoke: async ({ input, engine }) => {
+    await engine.signal(input.workflowId, input.signalName, input.payload, input.signalId === void 0 ? void 0 : { signalId: input.signalId });
+    return { ok: !0 };
+  }
+});
+function shapeSignalWorkflowSuccess(output) {
+  return new Response(JSON.stringify(output), {
+    status: 200,
+    headers: { "Content-Type": "application/json" }
+  });
+}
+export const signalWorkflowRestBinding = {
+  method: "POST",
+  path: "/v1/workflows/:id/signal/:name",
+  pathParamNames: ["id", "name"],
+  operationName: "weft.workflows.signal",
+  inputSources: {
+    workflowId: { kind: "path", pathParam: "id" },
+    signalName: { kind: "path", pathParam: "name" },
+    payload: { kind: "body-field", bodyField: "payload" }
+  },
+  extractInput: async (request, pathParams) => {
+    const body = await request.json().catch(() => null), payload = typeof body === "object" && body !== null ? body.payload : void 0, signalId = typeof body === "object" && body !== null ? body.signalId : void 0;
+    return {
+      ...extractWorkflowIdFromPath(pathParams),
+      signalName: pathParams.name ?? "",
+      payload,
+      ...signalId === void 0 ? {} : { signalId }
+    };
+  },
+  success: { kind: "json", status: 200 },
+  shapeSuccess: (output) => shapeSignalWorkflowSuccess(output),
+  shapeFault: shapeRestFault
+};

package/dist/server/operations/single-workflow-control-operation.d.ts

@@ -0,0 +1,32 @@
+import type { z } from 'zod';
+import type { Engine } from '../../core/engine.ts';
+import type { OperationDefinition } from '../operation-catalog.ts';
+import type { FaultCode, OperationFault } from '../operation-fault.ts';
+type SingleWorkflowControlInput = {
+    readonly workflowId: string;
+};
+type SingleWorkflowControlErrorMapper = (context: {
+    readonly error: unknown;
+    readonly message: string;
+    readonly workflowId: string;
+}) => OperationFault | undefined;
+type SingleWorkflowControlOperationConfiguration<Input extends SingleWorkflowControlInput, Output> = {
+    readonly name: string;
+    readonly summary: string;
+    /** Optional longer-form prose surfaced in discovery documents and the CLI. */
+    readonly description?: string;
+    readonly tags: ReadonlyArray<string>;
+    /** Whether this control operation irreversibly mutates state. Required. */
+    readonly destructive: boolean;
+    readonly inputSchema: z.ZodType<Input>;
+    readonly outputSchema: z.ZodType<Output>;
+    readonly producibleFaults: ReadonlyArray<FaultCode>;
+    readonly invoke: (context: {
+        readonly engine: Engine;
+        readonly input: Input;
+    }) => Promise<Output>;
+    readonly mapErrorToFault?: SingleWorkflowControlErrorMapper;
+};
+export declare function createSingleWorkflowControlOperation<Input extends SingleWorkflowControlInput, Output>(configuration: SingleWorkflowControlOperationConfiguration<Input, Output>): OperationDefinition<Input, Output>;
+export declare function extractWorkflowIdFromPath(pathParams: Readonly<Record<string, string | undefined>>): SingleWorkflowControlInput;
+export {};

package/dist/server/operations/single-workflow-control-operation.js

@@ -0,0 +1,44 @@
+import { defineOperation } from "../operation-registry.js";
+export function createSingleWorkflowControlOperation(configuration) {
+  return defineOperation({
+    name: configuration.name,
+    mcpExposable: !1,
+    summary: configuration.summary,
+    ...configuration.description === void 0 ? {} : { description: configuration.description },
+    tags: configuration.tags,
+    destructive: configuration.destructive,
+    inputSchema: configuration.inputSchema,
+    outputSchema: configuration.outputSchema,
+    access: { kind: "public" },
+    producibleFaults: configuration.producibleFaults,
+    transports: { http: !0, jsonRpcHttp: !0, jsonRpcWebSocket: !0, jsonRpcStdio: !0 },
+    unknownKeyPolicy: { http: "strip", jsonRpc: "reject" },
+    invoke: async ({ input, engine }) => {
+      try {
+        return await configuration.invoke({ engine, input });
+      } catch (error) {
+        throw mapSingleWorkflowControlErrorToFault(error, input.workflowId, configuration.mapErrorToFault);
+      }
+    }
+  });
+}
+export function extractWorkflowIdFromPath(pathParams) {
+  return { workflowId: pathParams.id ?? "" };
+}
+function mapSingleWorkflowControlErrorToFault(error, workflowId, mapErrorToFault) {
+  const message = error instanceof Error ? error.message : String(error);
+  if (message.includes("not found"))
+    return {
+      code: "NotFound",
+      message,
+      data: { resource: "workflow", identifier: workflowId }
+    };
+  const operationSpecificFault = mapErrorToFault?.({ error, message, workflowId });
+  if (operationSpecificFault !== void 0)
+    return operationSpecificFault;
+  return {
+    code: "EngineFailure",
+    message,
+    data: {}
+  };
+}

package/dist/server/operations/single-workflow-tag-mutation.d.ts

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+import type { Engine } from '../../core/engine.ts';
+import type { OperationDefinition } from '../operation-catalog.ts';
+import type { RestBinding } from '../rest-binding.ts';
+declare const singleWorkflowTagMutationInput: z.ZodObject<{
+    workflowId: z.ZodString;
+    tags: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>;
+declare const singleWorkflowTagMutationOutput: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+}, z.core.$strip>;
+export type SingleWorkflowTagMutationInput = z.infer<typeof singleWorkflowTagMutationInput>;
+export type SingleWorkflowTagMutationOutput = z.infer<typeof singleWorkflowTagMutationOutput>;
+type SingleWorkflowTagMutationOperationConfiguration = {
+    readonly name: string;
+    readonly summary: string;
+    /** Whether this tag mutation irreversibly mutates state. Required. */
+    readonly destructive: boolean;
+    readonly mutateTags: (engine: Engine, workflowId: string, tags: readonly string[]) => Promise<void>;
+};
+type SingleWorkflowTagMutationRestBindingConfiguration = {
+    readonly method: 'POST' | 'DELETE';
+    readonly operationName: string;
+};
+export declare function createSingleWorkflowTagMutationOperation(configuration: SingleWorkflowTagMutationOperationConfiguration): OperationDefinition<SingleWorkflowTagMutationInput, SingleWorkflowTagMutationOutput>;
+export declare function createSingleWorkflowTagMutationRestBinding(configuration: SingleWorkflowTagMutationRestBindingConfiguration): RestBinding<SingleWorkflowTagMutationInput, SingleWorkflowTagMutationOutput>;
+export {};

package/dist/server/operations/single-workflow-tag-mutation.js

@@ -0,0 +1,108 @@
+import { z } from "zod";
+import {
+  coerceStartWorkflowTags,
+  StartWorkflowValidationError
+} from "../../core/start-workflow-validation.js";
+import { defineOperation } from "../operation-registry.js";
+import { jsonErrorResponse, shapeRestFault } from "./operation-helpers.js";
+const singleWorkflowTagMutationInput = z.object({
+  workflowId: z.string().min(1),
+  tags: z.unknown().optional()
+}), singleWorkflowTagMutationOutput = z.object({
+  ok: z.literal(!0)
+});
+export function createSingleWorkflowTagMutationOperation(configuration) {
+  return defineOperation({
+    name: configuration.name,
+    mcpExposable: !1,
+    summary: configuration.summary,
+    tags: ["Tags"],
+    destructive: configuration.destructive,
+    inputSchema: singleWorkflowTagMutationInput,
+    outputSchema: singleWorkflowTagMutationOutput,
+    access: { kind: "public" },
+    producibleFaults: ["Unprocessable", "NotFound"],
+    transports: { http: !0, jsonRpcHttp: !0, jsonRpcWebSocket: !0, jsonRpcStdio: !0 },
+    unknownKeyPolicy: { http: "strip", jsonRpc: "reject" },
+    invoke: async ({ input, engine }) => {
+      let tags;
+      try {
+        tags = coerceStartWorkflowTags(input.tags, 'Field "tags"');
+      } catch (error) {
+        throw unprocessableFault(faultMessage(error));
+      }
+      try {
+        await configuration.mutateTags(engine, input.workflowId, tags);
+        return { ok: !0 };
+      } catch (error) {
+        throw mapTagMutationErrorToFault(error, input.workflowId);
+      }
+    }
+  });
+}
+export function createSingleWorkflowTagMutationRestBinding(configuration) {
+  return {
+    method: configuration.method,
+    path: "/v1/workflows/:id/tags",
+    pathParamNames: ["id"],
+    operationName: configuration.operationName,
+    inputSources: {
+      workflowId: { kind: "path", pathParam: "id" },
+      tags: { kind: "body-field", bodyField: "tags" }
+    },
+    extractInput: async (request, pathParams) => {
+      const body = await request.json().catch(() => {
+        throw Error("Invalid JSON body");
+      });
+      if (!isJsonObject(body))
+        throw Error("Invalid JSON body");
+      return {
+        workflowId: pathParams.id ?? "",
+        tags: body.tags
+      };
+    },
+    success: { kind: "json", status: 200 },
+    shapeSuccess: shapeSingleWorkflowTagMutationSuccess,
+    shapeFault: shapeSingleWorkflowTagMutationFault
+  };
+}
+function shapeSingleWorkflowTagMutationSuccess(output) {
+  return new Response(JSON.stringify(output), {
+    status: 200,
+    headers: { "Content-Type": "application/json" }
+  });
+}
+function shapeSingleWorkflowTagMutationFault(fault) {
+  if (fault.code === "Unprocessable")
+    return jsonErrorResponse(fault.message, 400);
+  return shapeRestFault(fault);
+}
+function mapTagMutationErrorToFault(error, workflowId) {
+  const message = faultMessage(error);
+  if (message.includes("not found"))
+    return {
+      code: "NotFound",
+      message,
+      data: { resource: "workflow", identifier: workflowId }
+    };
+  if (error instanceof StartWorkflowValidationError)
+    return unprocessableFault(message);
+  return {
+    code: "EngineFailure",
+    message,
+    data: {}
+  };
+}
+function unprocessableFault(message) {
+  return {
+    code: "Unprocessable",
+    message,
+    data: { reason: message }
+  };
+}
+function faultMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function isJsonObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/server/operations/sse-stream.d.ts

@@ -0,0 +1,13 @@
+import type { StoredStreamChunk } from '../../core/context.ts';
+/**
+ * Wrap a list of stored stream chunks as a Server-Sent Events stream. Each
+ * chunk gets emitted as a `token` event keyed by `chunk.sequence`; chunks
+ * whose mapped text is `null` are skipped. After the chunks, a single
+ * `done` event with empty data is emitted and the controller closes.
+ *
+ * Used by REST `shapeSuccess` for the streaming routes (`streamSSE`,
+ * `getStreamChunks` when negotiated to `text/event-stream`).
+ */
+export declare function createStoredChunkSSEStream(chunks: ReadonlyArray<StoredStreamChunk>, mapChunkToText: (chunk: StoredStreamChunk) => string | null): ReadableStream<Uint8Array>;
+/** Standard headers for an SSE response. */
+export declare const SSE_RESPONSE_HEADERS: Readonly<Record<string, string>>;

package/dist/server/operations/sse-stream.js

@@ -0,0 +1,42 @@
+const textEncoder = new TextEncoder;
+function formatSSE(event) {
+  const lines = [];
+  if (event.id !== void 0)
+    lines.push(`id: ${event.id}`);
+  if (event.event !== void 0)
+    lines.push(`event: ${event.event}`);
+  const dataLines = event.data.split(`
+`);
+  for (const line of dataLines)
+    lines.push(`data: ${line}`);
+  lines.push("");
+  return lines.join(`
+`) + `
+`;
+}
+export function createStoredChunkSSEStream(chunks, mapChunkToText) {
+  return new ReadableStream({
+    start(controller) {
+      for (const chunk of chunks) {
+        const text = mapChunkToText(chunk);
+        if (text === null)
+          continue;
+        controller.enqueue(textEncoder.encode(formatSSE({
+          id: String(chunk.sequence),
+          event: "token",
+          data: text
+        })));
+      }
+      controller.enqueue(textEncoder.encode(formatSSE({
+        event: "done",
+        data: ""
+      })));
+      controller.close();
+    }
+  });
+}
+export const SSE_RESPONSE_HEADERS = {
+  "Content-Type": "text/event-stream",
+  "Cache-Control": "no-cache",
+  Connection: "keep-alive"
+};

package/dist/server/operations/start-workflow.d.ts

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+import type { UnknownRestBinding } from '../rest-bindings.ts';
+declare const startWorkflowInput: z.ZodObject<{
+    type: z.ZodUnknown;
+    input: z.ZodOptional<z.ZodUnknown>;
+    id: z.ZodOptional<z.ZodUnknown>;
+    executionTimeout: z.ZodOptional<z.ZodUnknown>;
+    startAt: z.ZodOptional<z.ZodUnknown>;
+    startAfter: z.ZodOptional<z.ZodUnknown>;
+    tags: z.ZodOptional<z.ZodUnknown>;
+    idempotencyKey: z.ZodOptional<z.ZodUnknown>;
+    searchAttributes: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>;
+declare const startWorkflowOutput: z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$strip>;
+export type StartWorkflowInput = z.infer<typeof startWorkflowInput>;
+export type StartWorkflowOutput = z.infer<typeof startWorkflowOutput>;
+export declare const startWorkflowOperation: import("../operation-catalog.ts").OperationDefinition<{
+    type: unknown;
+    input?: unknown;
+    id?: unknown;
+    executionTimeout?: unknown;
+    startAt?: unknown;
+    startAfter?: unknown;
+    tags?: unknown;
+    idempotencyKey?: unknown;
+    searchAttributes?: unknown;
+}, {
+    id: string;
+}>;
+export declare const startWorkflowRestBinding: UnknownRestBinding;
+export {};