create-windy 0.3.2 → 0.3.5

package/template/packages/ai-client/src/speech/error.ts

@@ -0,0 +1,43 @@
+import type { SpeechErrorCode } from "./contracts.js";
+
+export class SpeechClientError extends Error {
+  constructor(
+    readonly code:
+      | SpeechErrorCode
+      | "INVALID_CONFIGURATION"
+      | "INVALID_RESPONSE",
+    message: string,
+    readonly retryable: boolean,
+    readonly requestId?: string,
+    options?: ErrorOptions,
+  ) {
+    super(message, options);
+    this.name = "SpeechClientError";
+  }
+}
+
+export async function speechHttpError(response: Response, fallback: string) {
+  try {
+    const value = (await response.json()) as Record<string, unknown>;
+    if (
+      typeof value.code === "string" &&
+      typeof value.message === "string" &&
+      typeof value.retryable === "boolean" &&
+      value.message.length <= 200
+    ) {
+      return new SpeechClientError(
+        value.code as SpeechErrorCode,
+        value.message,
+        value.retryable,
+        typeof value.requestId === "string" ? value.requestId : undefined,
+      );
+    }
+  } catch {
+    // Runtime 响应正文不可信，不向业务透传。
+  }
+  return new SpeechClientError(
+    "RUNTIME_UNAVAILABLE",
+    `${fallback}（HTTP ${response.status}）`,
+    response.status >= 500,
+  );
+}

package/template/packages/ai-client/src/speech/index.ts

@@ -0,0 +1,3 @@
+export * from "./client.js";
+export * from "./contracts.js";
+export * from "./error.js";

package/template/packages/ai-client/src/speech/run.ts

@@ -0,0 +1,133 @@
+import type {
+  OpenedSpeechResultArtifact,
+  SpeechEvent,
+  SpeechFetch,
+  SpeechRun,
+} from "./contracts.js";
+import { SpeechClientError, speechHttpError } from "./error.js";
+import {
+  parseArtifactMetadata,
+  parseSpeechEvent,
+  record,
+} from "./validation.js";
+
+export interface HttpSpeechRunInput<Output> {
+  id: string;
+  eventsUrl: URL;
+  resultUrl: URL;
+  artifactUrl: URL;
+  cancelUrl: URL;
+  fetch: SpeechFetch;
+  signal?: AbortSignal;
+  parseOutput(value: unknown): Output;
+}
+
+export class HttpSpeechRun<Output> implements SpeechRun<Output> {
+  readonly id: string;
+  readonly events: AsyncIterable<SpeechEvent>;
+
+  constructor(private readonly input: HttpSpeechRunInput<Output>) {
+    this.id = input.id;
+    this.events = streamEvents(input);
+  }
+
+  async result(): Promise<Output> {
+    const response = await this.input.fetch(this.input.resultUrl, {
+      signal: this.input.signal,
+    });
+    if (!response.ok) throw await speechHttpError(response, "读取转写结果失败");
+    return this.input.parseOutput(
+      record(await response.json(), "SpeechResult").output,
+    );
+  }
+
+  async artifact(): Promise<OpenedSpeechResultArtifact> {
+    const response = await this.input.fetch(this.input.artifactUrl, {
+      signal: this.input.signal,
+    });
+    if (!response.ok)
+      throw await speechHttpError(response, "读取转写 Artifact 失败");
+    if (!response.body) {
+      throw new SpeechClientError(
+        "INVALID_RESPONSE",
+        "Speech Runtime 未返回 Artifact 内容",
+        false,
+      );
+    }
+    const metadata = parseArtifactMetadata({
+      mediaType: response.headers.get("content-type"),
+      byteSize: Number(response.headers.get("content-length")),
+      sha256: response.headers.get("x-content-sha256"),
+    });
+    return { ...metadata, body: response.body };
+  }
+
+  async cancel(reason?: string): Promise<void> {
+    const response = await this.input.fetch(this.input.cancelUrl, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ reason: reason?.slice(0, 200) }),
+      signal: this.input.signal,
+    });
+    if (!response.ok) throw await speechHttpError(response, "取消转写任务失败");
+  }
+}
+
+async function* streamEvents<Output>(
+  input: HttpSpeechRunInput<Output>,
+): AsyncIterable<SpeechEvent> {
+  let cursor = 0;
+  while (true) {
+    const url = new URL(input.eventsUrl);
+    url.searchParams.set("after", String(cursor));
+    const response = await input.fetch(url, { signal: input.signal });
+    if (!response.ok) throw await speechHttpError(response, "读取转写事件失败");
+    if (!response.body) {
+      throw new SpeechClientError(
+        "INVALID_RESPONSE",
+        "Speech Runtime 未返回事件流",
+        true,
+      );
+    }
+    for await (const event of decodeSse(response.body)) {
+      const parsed = parseSpeechEvent(event);
+      if (parsed.sequence <= cursor) continue;
+      cursor = parsed.sequence;
+      yield parsed;
+      if (
+        ["run.completed", "run.failed", "run.cancelled"].includes(parsed.type)
+      ) {
+        return;
+      }
+    }
+  }
+}
+
+async function* decodeSse(body: ReadableStream<Uint8Array>) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  try {
+    while (true) {
+      const chunk = await reader.read();
+      if (chunk.done) return;
+      buffer += decoder
+        .decode(chunk.value, { stream: true })
+        .replaceAll("\r\n", "\n");
+      let boundary = buffer.indexOf("\n\n");
+      while (boundary >= 0) {
+        const frame = buffer.slice(0, boundary);
+        buffer = buffer.slice(boundary + 2);
+        const data = frame
+          .split("\n")
+          .filter((line) => line.startsWith("data:"))
+          .map((line) => line.slice(5).trimStart())
+          .join("\n");
+        if (data) yield JSON.parse(data) as unknown;
+        boundary = buffer.indexOf("\n\n");
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}

package/template/packages/ai-client/src/speech/validation.ts

@@ -0,0 +1,132 @@
+import type { ArtifactRef } from "../artifact-ref.js";
+import type {
+  SpeechErrorPayload,
+  SpeechEvent,
+  SpeechResultArtifactMetadata,
+  SpeechRunStatus,
+} from "./contracts.js";
+import { SpeechClientError } from "./error.js";
+
+export function parseArtifactRef(value: unknown): ArtifactRef {
+  const item = record(value, "ArtifactRef");
+  const sha256 = text(item.sha256, "ArtifactRef.sha256");
+  if (!/^[a-f0-9]{64}$/.test(sha256)) invalid("ArtifactRef.sha256");
+  return {
+    value: text(item.value, "ArtifactRef.value"),
+    mediaType: text(item.mediaType, "ArtifactRef.mediaType"),
+    byteSize: integer(item.byteSize, "ArtifactRef.byteSize", 0),
+    sha256,
+    ...(item.expiresAt === undefined
+      ? {}
+      : { expiresAt: text(item.expiresAt, "ArtifactRef.expiresAt") }),
+  };
+}
+
+export function parseCreatedRun(value: unknown): {
+  runId: string;
+  status: SpeechRunStatus;
+  eventsUrl: string;
+} {
+  const item = record(value, "SpeechRun");
+  const status = text(item.status, "SpeechRun.status");
+  if (
+    !["accepted", "running", "completed", "failed", "cancelled"].includes(
+      status,
+    )
+  ) {
+    invalid("SpeechRun.status");
+  }
+  return {
+    runId: text(item.runId, "SpeechRun.runId"),
+    status: status as SpeechRunStatus,
+    eventsUrl: text(item.eventsUrl, "SpeechRun.eventsUrl"),
+  };
+}
+
+export function parseSpeechEvent(value: unknown): SpeechEvent {
+  const item = record(value, "SpeechEvent");
+  const type = text(item.type, "SpeechEvent.type");
+  const base = {
+    runId: text(item.runId, "SpeechEvent.runId"),
+    sequence: integer(item.sequence, "SpeechEvent.sequence", 1),
+  };
+  if (
+    type === "run.started" ||
+    type === "run.completed" ||
+    type === "run.cancelled"
+  ) {
+    return { type, ...base };
+  }
+  if (type === "speech.segment.completed") {
+    return {
+      type,
+      ...base,
+      completedSegments: integer(
+        item.completedSegments,
+        "SpeechEvent.completedSegments",
+        1,
+      ),
+      totalSegments: integer(
+        item.totalSegments,
+        "SpeechEvent.totalSegments",
+        1,
+      ),
+      endMs: integer(item.endMs, "SpeechEvent.endMs", 0),
+    };
+  }
+  if (type === "run.failed") {
+    return { type, ...base, error: parseError(item.error) };
+  }
+  invalid("SpeechEvent.type");
+}
+
+export function parseArtifactMetadata(
+  value: unknown,
+): SpeechResultArtifactMetadata {
+  const item = record(value, "SpeechArtifact");
+  const sha256 = text(item.sha256, "SpeechArtifact.sha256");
+  if (!/^[a-f0-9]{64}$/.test(sha256)) invalid("SpeechArtifact.sha256");
+  if (item.mediaType !== "application/json") {
+    invalid("SpeechArtifact.mediaType");
+  }
+  return {
+    mediaType: "application/json",
+    byteSize: integer(item.byteSize, "SpeechArtifact.byteSize", 1),
+    sha256,
+  };
+}
+
+export function record(value: unknown, path: string) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    invalid(path);
+  }
+  return value as Record<string, unknown>;
+}
+
+function parseError(value: unknown): SpeechErrorPayload {
+  const item = record(value, "SpeechError");
+  return {
+    code: text(item.code, "SpeechError.code") as SpeechErrorPayload["code"],
+    message: text(item.message, "SpeechError.message"),
+    requestId: text(item.requestId, "SpeechError.requestId"),
+    retryable: item.retryable === true,
+  };
+}
+
+function text(value: unknown, path: string) {
+  if (typeof value !== "string" || !value.trim()) invalid(path);
+  return value;
+}
+
+function integer(value: unknown, path: string, minimum: number) {
+  if (!Number.isSafeInteger(value) || Number(value) < minimum) invalid(path);
+  return Number(value);
+}
+
+function invalid(path: string): never {
+  throw new SpeechClientError(
+    "INVALID_RESPONSE",
+    `Speech Runtime 响应字段无效：${path}`,
+    false,
+  );
+}

package/template/packages/config/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@southwind-ai/config",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "license": "UNLICENSED",
   "type": "module",
   "engines": {
@@ -13,7 +13,7 @@
     "!src/**/*.test.ts"
   ],
   "dependencies": {
-    "@southwind-ai/shared": "workspace:*",
+    "@southwind-ai/shared": "workspace:^",
     "zod": "^4.4.3"
   },
   "exports": {

package/template/packages/database/drizzle/0039_early_ezekiel_stane.sql

@@ -0,0 +1 @@
+ALTER TABLE "durable_jobs" ADD COLUMN "authorization_scope" jsonb;

package/template/packages/database/drizzle/0040_colossal_baron_strucker.sql

@@ -0,0 +1,63 @@
+CREATE TABLE "agent_evaluation_results" (
+	"evaluation_id" varchar(80) PRIMARY KEY NOT NULL,
+	"release_id" varchar(80) NOT NULL,
+	"evaluation_set_key" varchar(160) NOT NULL,
+	"evaluation_set_version" varchar(80) NOT NULL,
+	"metrics_json" jsonb NOT NULL,
+	"created_at" double precision NOT NULL
+);
+--> statement-breakpoint
+CREATE TABLE "agent_operation_releases" (
+	"release_id" varchar(80) PRIMARY KEY NOT NULL,
+	"operation_key" varchar(200) NOT NULL,
+	"snapshot_json" jsonb NOT NULL,
+	"created_at" double precision NOT NULL
+);
+--> statement-breakpoint
+CREATE TABLE "agent_runtime_events" (
+	"run_id" varchar(80) NOT NULL,
+	"sequence" integer NOT NULL,
+	"event_cipher" text NOT NULL,
+	CONSTRAINT "agent_runtime_events_run_id_sequence_pk" PRIMARY KEY("run_id","sequence"),
+	CONSTRAINT "ck_agent_runtime_events_sequence" CHECK ("agent_runtime_events"."sequence" > 0)
+);
+--> statement-breakpoint
+CREATE TABLE "agent_runtime_runs" (
+	"run_id" varchar(80) PRIMARY KEY NOT NULL,
+	"operation_key" varchar(200) NOT NULL,
+	"idempotency_key" varchar(200) NOT NULL,
+	"fingerprint" varchar(64) NOT NULL,
+	"status" varchar(32) NOT NULL,
+	"invocation_cipher" text,
+	"output_cipher" text,
+	"release_id" varchar(80) NOT NULL,
+	"release_json" jsonb NOT NULL,
+	"trace_id" varchar(160) NOT NULL,
+	"lease_owner" varchar(80),
+	"lease_until" double precision DEFAULT 0 NOT NULL,
+	"created_at" double precision NOT NULL,
+	"updated_at" double precision NOT NULL,
+	"expires_at" double precision NOT NULL,
+	CONSTRAINT "ck_agent_runtime_runs_status" CHECK ("agent_runtime_runs"."status" in ('accepted', 'running', 'awaiting-approval', 'completed', 'failed', 'cancelled'))
+);
+--> statement-breakpoint
+ALTER TABLE "agent_evaluation_results" ADD CONSTRAINT "agent_evaluation_results_release_id_agent_operation_releases_release_id_fk" FOREIGN KEY ("release_id") REFERENCES "public"."agent_operation_releases"("release_id") ON DELETE restrict ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "agent_runtime_events" ADD CONSTRAINT "agent_runtime_events_run_id_agent_runtime_runs_run_id_fk" FOREIGN KEY ("run_id") REFERENCES "public"."agent_runtime_runs"("run_id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "agent_runtime_runs" ADD CONSTRAINT "agent_runtime_runs_release_id_agent_operation_releases_release_id_fk" FOREIGN KEY ("release_id") REFERENCES "public"."agent_operation_releases"("release_id") ON DELETE restrict ON UPDATE no action;--> statement-breakpoint
+CREATE UNIQUE INDEX "uk_agent_evaluation_release_set" ON "agent_evaluation_results" USING btree ("release_id","evaluation_set_key","evaluation_set_version");--> statement-breakpoint
+CREATE INDEX "idx_agent_releases_operation" ON "agent_operation_releases" USING btree ("operation_key","created_at");--> statement-breakpoint
+CREATE UNIQUE INDEX "uk_agent_runtime_runs_idempotency" ON "agent_runtime_runs" USING btree ("idempotency_key");--> statement-breakpoint
+CREATE INDEX "idx_agent_runtime_runs_recovery" ON "agent_runtime_runs" USING btree ("status","lease_until");--> statement-breakpoint
+CREATE INDEX "idx_agent_runtime_runs_release" ON "agent_runtime_runs" USING btree ("release_id","created_at");--> statement-breakpoint
+CREATE INDEX "idx_agent_runtime_runs_expiry" ON "agent_runtime_runs" USING btree ("status","expires_at");
+--> statement-breakpoint
+CREATE OR REPLACE FUNCTION windy_reject_agent_release_mutation()
+RETURNS trigger AS $$
+BEGIN
+  RAISE EXCEPTION 'agent operation releases are immutable';
+END;
+$$ LANGUAGE plpgsql;
+--> statement-breakpoint
+CREATE TRIGGER "trg_agent_operation_releases_immutable"
+BEFORE UPDATE OR DELETE ON "agent_operation_releases"
+FOR EACH ROW EXECUTE FUNCTION windy_reject_agent_release_mutation();

package/template/packages/database/drizzle/0041_yummy_prowler.sql

@@ -0,0 +1,21 @@
+CREATE TABLE "agent_run_bindings" (
+	"binding_id" varchar(80) PRIMARY KEY NOT NULL,
+	"run_id" varchar(80),
+	"operation_key" varchar(200) NOT NULL,
+	"actor_id" varchar(64) NOT NULL,
+	"idempotency_hash" varchar(64) NOT NULL,
+	"token_hash" varchar(64) NOT NULL,
+	"scope_hash" varchar(64) NOT NULL,
+	"scope_snapshot" jsonb NOT NULL,
+	"authorization_snapshot" jsonb NOT NULL,
+	"release_id" varchar(80) NOT NULL,
+	"created_at" double precision NOT NULL,
+	"bound_at" double precision,
+	"expires_at" double precision NOT NULL
+);
+--> statement-breakpoint
+CREATE UNIQUE INDEX "uk_agent_run_bindings_run" ON "agent_run_bindings" USING btree ("run_id");--> statement-breakpoint
+CREATE UNIQUE INDEX "uk_agent_run_bindings_idempotency" ON "agent_run_bindings" USING btree ("idempotency_hash");--> statement-breakpoint
+CREATE UNIQUE INDEX "uk_agent_run_bindings_token" ON "agent_run_bindings" USING btree ("token_hash");--> statement-breakpoint
+CREATE INDEX "idx_agent_run_bindings_actor" ON "agent_run_bindings" USING btree ("actor_id","expires_at");--> statement-breakpoint
+CREATE INDEX "idx_agent_run_bindings_expiry" ON "agent_run_bindings" USING btree ("expires_at");

package/template/packages/database/drizzle/0042_puzzling_rumiko_fujikawa.sql

@@ -0,0 +1,27 @@
+ALTER TABLE "durable_job_artifacts" ADD COLUMN "metadata" jsonb;--> statement-breakpoint
+ALTER TABLE "governed_export_requests" ADD COLUMN "renderer" jsonb;--> statement-breakpoint
+UPDATE "governed_export_requests"
+SET "renderer" = jsonb_build_object(
+  'formatKey', 'ndjson',
+  'templateKey', 'system.governed-export.ndjson',
+  'templateVersion', '1',
+  'inputSchemaKey', 'system.governed-export.record.v1',
+  'contentType', 'application/x-ndjson',
+  'filenameExtension', 'ndjson',
+  'maxRecords', 50000,
+  'maxOutputBytes', 10485760,
+  'timeoutSeconds', 900
+)
+WHERE "renderer" IS NULL;--> statement-breakpoint
+UPDATE "durable_job_artifacts" AS artifact
+SET "metadata" = jsonb_build_object(
+  'formatKey', request."renderer" ->> 'formatKey',
+  'templateKey', request."renderer" ->> 'templateKey',
+  'templateVersion', request."renderer" ->> 'templateVersion',
+  'inputSchemaKey', request."renderer" ->> 'inputSchemaKey'
+)
+FROM "governed_export_requests" AS request
+WHERE request."durable_job_id" = artifact."job_id"
+  AND artifact."kind" = 'governed-export'
+  AND artifact."metadata" IS NULL;--> statement-breakpoint
+ALTER TABLE "governed_export_requests" ALTER COLUMN "renderer" SET NOT NULL;