create-windy 0.6.12 → 0.6.15

package/template/packages/database/src/schema/agent-workflow-evaluation.ts

@@ -0,0 +1,67 @@
+import { sql } from "drizzle-orm";
+import {
+  check,
+  doublePrecision,
+  index,
+  jsonb,
+  pgTable,
+  text,
+  uniqueIndex,
+  varchar,
+} from "drizzle-orm/pg-core";
+import type {
+  AgentWorkflowEvaluationArm,
+  AgentWorkflowEvaluationIdentity,
+} from "@southwind-ai/shared";
+
+export const agentWorkflowEvaluations = pgTable(
+  "agent_workflow_evaluations",
+  {
+    evaluationId: varchar("evaluation_id", { length: 96 }).primaryKey(),
+    tenantId: varchar("tenant_id", { length: 64 }).notNull(),
+    createdBy: varchar("created_by", { length: 64 }).notNull(),
+    evaluationSetKey: varchar("evaluation_set_key", { length: 160 }).notNull(),
+    evaluationSetVersion: varchar("evaluation_set_version", {
+      length: 80,
+    }).notNull(),
+    identityDigest: varchar("identity_digest", { length: 71 }).notNull(),
+    identityJson: jsonb("identity_json")
+      .$type<AgentWorkflowEvaluationIdentity>()
+      .notNull(),
+    singleArmJson: jsonb("single_arm_json")
+      .$type<AgentWorkflowEvaluationArm>()
+      .notNull(),
+    multiArmJson: jsonb("multi_arm_json")
+      .$type<AgentWorkflowEvaluationArm>()
+      .notNull(),
+    status: varchar("status", { length: 24 }).notNull(),
+    dispositionReason: text("disposition_reason"),
+    createdAt: doublePrecision("created_at").notNull(),
+    completedAt: doublePrecision("completed_at"),
+  },
+  (table) => [
+    uniqueIndex("uk_agent_workflow_evaluation_identity").on(
+      table.tenantId,
+      table.createdBy,
+      table.evaluationSetKey,
+      table.evaluationSetVersion,
+      table.identityDigest,
+    ),
+    index("idx_agent_workflow_evaluation_created").on(table.createdAt),
+    index("idx_agent_workflow_evaluation_actor").on(
+      table.tenantId,
+      table.createdBy,
+      table.createdAt,
+    ),
+    check(
+      "ck_agent_workflow_evaluation_status",
+      sql`${table.status} in ('pending', 'completed', 'unavailable', 'non-comparable')`,
+    ),
+    check(
+      "ck_agent_workflow_evaluation_result",
+      sql`(${table.status} = 'pending' and ${table.completedAt} is null)
+        or (${table.status} = 'completed' and ${table.completedAt} is not null and ${table.dispositionReason} is null)
+        or (${table.status} in ('unavailable', 'non-comparable') and ${table.completedAt} is not null and ${table.dispositionReason} is not null)`,
+    ),
+  ],
+);

package/template/packages/database/src/schema/agent-workflow.ts

@@ -0,0 +1,270 @@
+import { sql } from "drizzle-orm";
+import {
+  check,
+  doublePrecision,
+  foreignKey,
+  index,
+  integer,
+  jsonb,
+  pgTable,
+  primaryKey,
+  uniqueIndex,
+  varchar,
+} from "drizzle-orm/pg-core";
+import type {
+  AgentWorkflowArtifactRef,
+  AgentWorkflowBudget,
+  AgentWorkflowDefinition,
+  AgentWorkflowInputReceipt,
+  AgentWorkflowNodeResultReceipt,
+  AgentWorkflowReleaseCoordinates,
+  AgentWorkflowUsage,
+  AgentWorkflowEventData,
+} from "@southwind-ai/shared";
+
+export const agentWorkflowDefinitions = pgTable(
+  "agent_workflow_definitions",
+  {
+    definitionId: varchar("definition_id", { length: 96 }).primaryKey(),
+    workflowKey: varchar("workflow_key", { length: 160 }).notNull(),
+    version: varchar("version", { length: 80 }).notNull(),
+    definitionDigest: varchar("definition_digest", { length: 71 }).notNull(),
+    definitionJson: jsonb("definition_json")
+      .$type<AgentWorkflowDefinition>()
+      .notNull(),
+    createdBy: varchar("created_by", { length: 64 }).notNull(),
+    createdAt: doublePrecision("created_at").notNull(),
+  },
+  (table) => [
+    uniqueIndex("uk_agent_workflow_definition_version").on(
+      table.workflowKey,
+      table.version,
+    ),
+    uniqueIndex("uk_agent_workflow_definition_digest").on(
+      table.workflowKey,
+      table.definitionDigest,
+    ),
+  ],
+);
+
+export const agentWorkflowReleases = pgTable(
+  "agent_workflow_releases",
+  {
+    releaseId: varchar("release_id", { length: 96 }).primaryKey(),
+    releaseDigest: varchar("release_digest", { length: 71 }).notNull(),
+    definitionId: varchar("definition_id", { length: 96 })
+      .notNull()
+      .references(() => agentWorkflowDefinitions.definitionId, {
+        onDelete: "restrict",
+      }),
+    definitionDigest: varchar("definition_digest", { length: 71 }).notNull(),
+    releaseJson: jsonb("release_json")
+      .$type<{
+        definition: AgentWorkflowDefinition;
+        coordinates: AgentWorkflowReleaseCoordinates;
+      }>()
+      .notNull(),
+    publishedBy: varchar("published_by", { length: 64 }).notNull(),
+    publishedAt: doublePrecision("published_at").notNull(),
+  },
+  (table) => [
+    uniqueIndex("uk_agent_workflow_release_definition").on(table.definitionId),
+    uniqueIndex("uk_agent_workflow_release_digest").on(table.releaseDigest),
+    index("idx_agent_workflow_release_published").on(table.publishedAt),
+  ],
+);
+
+export const agentWorkflowRuns = pgTable(
+  "agent_workflow_runs",
+  {
+    runId: varchar("run_id", { length: 96 }).primaryKey(),
+    releaseId: varchar("release_id", { length: 96 })
+      .notNull()
+      .references(() => agentWorkflowReleases.releaseId, {
+        onDelete: "restrict",
+      }),
+    idempotencyKey: varchar("idempotency_key", { length: 200 }).notNull(),
+    tenantId: varchar("tenant_id", { length: 64 }).notNull(),
+    actorId: varchar("actor_id", { length: 64 }).notNull(),
+    routeKey: varchar("route_key", { length: 160 }).notNull(),
+    inputDigest: varchar("input_digest", { length: 71 }).notNull(),
+    inputReceiptJson: jsonb("input_receipt_json")
+      .$type<AgentWorkflowInputReceipt>()
+      .notNull(),
+    scopeDigest: varchar("scope_digest", { length: 71 }).notNull(),
+    authorizationSnapshotDigest: varchar("authorization_snapshot_digest", {
+      length: 71,
+    }).notNull(),
+    toolPolicyDigest: varchar("tool_policy_digest", { length: 71 }).notNull(),
+    workspacePolicyDigest: varchar("workspace_policy_digest", {
+      length: 71,
+    }).notNull(),
+    executionPolicyDigest: varchar("execution_policy_digest", {
+      length: 71,
+    }).notNull(),
+    sessionId: varchar("session_id", { length: 80 }),
+    parentRunId: varchar("parent_run_id", { length: 96 }),
+    parentNodeId: varchar("parent_node_id", { length: 96 }),
+    parentNodeRunId: varchar("parent_node_run_id", { length: 96 }),
+    status: varchar("status", { length: 24 }).notNull(),
+    budgetJson: jsonb("budget_json").$type<AgentWorkflowBudget>().notNull(),
+    usageJson: jsonb("usage_json").$type<AgentWorkflowUsage>().notNull(),
+    deadlineAt: doublePrecision("deadline_at").notNull(),
+    cancellationRequestedAt: doublePrecision("cancellation_requested_at"),
+    safeErrorCode: varchar("safe_error_code", { length: 80 }),
+    recoveryCount: integer("recovery_count").notNull().default(0),
+    version: integer("version").notNull().default(1),
+    createdAt: doublePrecision("created_at").notNull(),
+    updatedAt: doublePrecision("updated_at").notNull(),
+    finishedAt: doublePrecision("finished_at"),
+  },
+  (table) => [
+    uniqueIndex("uk_agent_workflow_run_idempotency").on(
+      table.tenantId,
+      table.actorId,
+      table.releaseId,
+      table.routeKey,
+      table.inputDigest,
+      table.idempotencyKey,
+    ),
+    index("idx_agent_workflow_run_actor").on(table.actorId, table.createdAt),
+    index("idx_agent_workflow_run_recovery").on(table.status, table.updatedAt),
+    index("idx_agent_workflow_run_parent").on(table.parentRunId),
+    check(
+      "ck_agent_workflow_run_status",
+      sql`${table.status} in ('accepted', 'running', 'waiting', 'completed', 'failed', 'cancelled', 'timed-out')`,
+    ),
+    check("ck_agent_workflow_run_version", sql`${table.version} > 0`),
+    check(
+      "ck_agent_workflow_run_recovery_count",
+      sql`${table.recoveryCount} >= 0`,
+    ),
+    check(
+      "ck_agent_workflow_run_parent",
+      sql`(${table.parentRunId} is null and ${table.parentNodeId} is null and ${table.parentNodeRunId} is null) or (${table.parentRunId} is not null and ${table.parentNodeId} is not null and ${table.parentNodeRunId} is not null)`,
+    ),
+    check(
+      "ck_agent_workflow_run_terminal_time",
+      sql`(${table.status} in ('completed', 'failed', 'cancelled', 'timed-out') and ${table.finishedAt} is not null) or (${table.status} in ('accepted', 'running', 'waiting') and ${table.finishedAt} is null)`,
+    ),
+    check(
+      "ck_agent_workflow_run_time_order",
+      sql`${table.createdAt} <= ${table.updatedAt} and ${table.deadlineAt} >= ${table.createdAt}
+        and (${table.cancellationRequestedAt} is null or (${table.cancellationRequestedAt} >= ${table.createdAt} and ${table.cancellationRequestedAt} <= ${table.updatedAt}))
+        and (${table.finishedAt} is null or (${table.finishedAt} >= ${table.createdAt} and ${table.finishedAt} <= ${table.updatedAt}))`,
+    ),
+  ],
+);
+
+export const agentWorkflowNodeRuns = pgTable(
+  "agent_workflow_node_runs",
+  {
+    nodeRunId: varchar("node_run_id", { length: 96 }).primaryKey(),
+    runId: varchar("run_id", { length: 96 })
+      .notNull()
+      .references(() => agentWorkflowRuns.runId, { onDelete: "restrict" }),
+    nodeId: varchar("node_id", { length: 96 }).notNull(),
+    previousNodeRunId: varchar("previous_node_run_id", { length: 96 }),
+    nodeType: varchar("node_type", { length: 24 }).notNull(),
+    status: varchar("status", { length: 24 }).notNull(),
+    attempt: integer("attempt").notNull().default(0),
+    maxAttempts: integer("max_attempts").notNull(),
+    idempotencyKey: varchar("idempotency_key", { length: 220 }).notNull(),
+    adapterKind: varchar("adapter_kind", { length: 32 }),
+    adapterCoordinate: varchar("adapter_coordinate", { length: 220 }),
+    inputArtifactsJson: jsonb("input_artifacts_json")
+      .$type<readonly AgentWorkflowArtifactRef[]>()
+      .notNull(),
+    outputArtifactsJson: jsonb("output_artifacts_json")
+      .$type<readonly AgentWorkflowArtifactRef[]>()
+      .notNull(),
+    resultReceiptJson: jsonb(
+      "result_receipt_json",
+    ).$type<AgentWorkflowNodeResultReceipt>(),
+    safeErrorCode: varchar("safe_error_code", { length: 80 }),
+    createdAt: doublePrecision("created_at").notNull(),
+    updatedAt: doublePrecision("updated_at").notNull(),
+    startedAt: doublePrecision("started_at"),
+    finishedAt: doublePrecision("finished_at"),
+    version: integer("version").notNull().default(1),
+  },
+  (table) => [
+    uniqueIndex("uk_agent_workflow_node_attempt").on(
+      table.runId,
+      table.nodeId,
+      table.attempt,
+    ),
+    uniqueIndex("uk_agent_workflow_node_idempotency").on(table.idempotencyKey),
+    uniqueIndex("uk_agent_workflow_node_coordinate").on(
+      table.nodeRunId,
+      table.runId,
+    ),
+    index("idx_agent_workflow_node_status").on(table.runId, table.status),
+    foreignKey({
+      columns: [table.previousNodeRunId, table.runId],
+      foreignColumns: [table.nodeRunId, table.runId],
+      name: "fk_agent_workflow_node_previous_attempt",
+    }).onDelete("restrict"),
+    check(
+      "ck_agent_workflow_node_type",
+      sql`${table.nodeType} in ('model', 'tool', 'subagent', 'condition', 'parallel', 'join', 'approval', 'job', 'wait', 'artifact', 'final')`,
+    ),
+    check(
+      "ck_agent_workflow_node_status",
+      sql`${table.status} in ('pending', 'ready', 'running', 'waiting', 'retry-scheduled', 'completed', 'failed', 'cancelled', 'skipped', 'timed-out')`,
+    ),
+    check(
+      "ck_agent_workflow_node_attempts",
+      sql`${table.attempt} > 0 and ${table.maxAttempts} > 0 and ${table.attempt} <= ${table.maxAttempts}`,
+    ),
+    check(
+      "ck_agent_workflow_node_previous_attempt",
+      sql`(${table.attempt} = 1 and ${table.previousNodeRunId} is null) or (${table.attempt} > 1 and ${table.previousNodeRunId} is not null)`,
+    ),
+    check("ck_agent_workflow_node_version", sql`${table.version} > 0`),
+    check(
+      "ck_agent_workflow_node_terminal_time",
+      sql`(${table.status} in ('completed', 'failed', 'cancelled', 'skipped', 'timed-out', 'retry-scheduled') and ${table.finishedAt} is not null) or (${table.status} in ('pending', 'ready', 'running', 'waiting') and ${table.finishedAt} is null)`,
+    ),
+    check(
+      "ck_agent_workflow_node_time_order",
+      sql`${table.createdAt} <= ${table.updatedAt}
+        and (${table.startedAt} is null or (${table.startedAt} >= ${table.createdAt} and ${table.startedAt} <= ${table.updatedAt}))
+        and (${table.finishedAt} is null or (${table.finishedAt} >= coalesce(${table.startedAt}, ${table.createdAt}) and ${table.finishedAt} <= ${table.updatedAt}))`,
+    ),
+    check(
+      "ck_agent_workflow_node_result_receipt",
+      sql`${table.status} <> 'completed' or ${table.resultReceiptJson} is not null`,
+    ),
+    check(
+      "ck_agent_workflow_node_adapter",
+      sql`(${table.adapterKind} is null and ${table.adapterCoordinate} is null) or (${table.adapterKind} in ('model-operation', 'agent-tool', 'child-agent', 'approval-work-item', 'durable-job', 'wait-signal', 'artifact-store', 'finalizer') and ${table.adapterCoordinate} is not null)`,
+    ),
+  ],
+);
+
+export const agentWorkflowEvents = pgTable(
+  "agent_workflow_events",
+  {
+    eventId: varchar("event_id", { length: 96 }).notNull(),
+    runId: varchar("run_id", { length: 96 })
+      .notNull()
+      .references(() => agentWorkflowRuns.runId, { onDelete: "restrict" }),
+    sequence: integer("sequence").notNull(),
+    eventType: varchar("event_type", { length: 80 }).notNull(),
+    parentEventId: varchar("parent_event_id", { length: 96 }),
+    causationEventId: varchar("causation_event_id", { length: 96 }),
+    childWorkflowRunId: varchar("child_workflow_run_id", { length: 96 }),
+    payloadJson: jsonb("payload_json")
+      .$type<AgentWorkflowEventData>()
+      .notNull(),
+    occurredAt: doublePrecision("occurred_at").notNull(),
+  },
+  (table) => [
+    primaryKey({ columns: [table.runId, table.sequence] }),
+    uniqueIndex("uk_agent_workflow_event_id").on(table.eventId),
+    index("idx_agent_workflow_event_parent").on(table.parentEventId),
+    index("idx_agent_workflow_event_causation").on(table.causationEventId),
+    check("ck_agent_workflow_event_sequence", sql`${table.sequence} > 0`),
+  ],
+);

package/template/packages/database/src/schema/client-agent-workflow-artifact.ts

@@ -0,0 +1,158 @@
+import { sql } from "drizzle-orm";
+import {
+  check,
+  doublePrecision,
+  foreignKey,
+  index,
+  integer,
+  jsonb,
+  pgTable,
+  uniqueIndex,
+  varchar,
+} from "drizzle-orm/pg-core";
+import { durableJobs } from "./durable-jobs.js";
+import { clientAgentSessions } from "./client-agent.js";
+import { agentWorkflowSideEffectCommands } from "./agent-workflow-effects.js";
+
+export type ClientAgentWorkflowArtifactStatus =
+  | "pending"
+  | "claimed"
+  | "cancellation-requested"
+  | "completed"
+  | "cancelled";
+
+/**
+ * Workflow effect 与浏览器 Client Agent Session 之间的唯一桥接事实。
+ * 原始对话和 Provider 配置不在这里持久化；逐次执行历史继续由
+ * client_agent_receipts 承载。
+ */
+export const clientAgentWorkflowArtifacts = pgTable(
+  "client_agent_workflow_artifacts",
+  {
+    workId: varchar("work_id", { length: 80 }).primaryKey(),
+    commandId: varchar("command_id", { length: 96 }).notNull(),
+    durableJobId: varchar("durable_job_id", { length: 64 })
+      .notNull()
+      .references(() => durableJobs.id, { onDelete: "restrict" }),
+    runId: varchar("run_id", { length: 96 }).notNull(),
+    nodeRunId: varchar("node_run_id", { length: 96 }).notNull(),
+    effectKind: varchar("effect_kind", { length: 24 }).$type<"job">().notNull(),
+    taskKey: varchar("task_key", { length: 160 }).notNull(),
+    operationKey: varchar("operation_key", { length: 200 }).notNull(),
+    bindingDigest: varchar("binding_digest", { length: 71 }).notNull(),
+    actorId: varchar("actor_id", { length: 64 }).notNull(),
+    scopeDigest: varchar("scope_digest", { length: 71 }).notNull(),
+    authorizationSnapshotDigest: varchar("authorization_snapshot_digest", {
+      length: 71,
+    }).notNull(),
+    runPolicyDigest: varchar("run_policy_digest", { length: 71 }).notNull(),
+    requestDigest: varchar("request_digest", { length: 71 }).notNull(),
+    inputDigest: varchar("input_digest", { length: 71 }).notNull(),
+    effectGeneration: integer("effect_generation").notNull(),
+    effectFenceTokenDigest: varchar("effect_fence_token_digest", {
+      length: 71,
+    }).notNull(),
+    status: varchar("status", { length: 32 })
+      .$type<ClientAgentWorkflowArtifactStatus>()
+      .notNull(),
+    claimGeneration: integer("claim_generation").notNull().default(0),
+    clientBindingDigest: varchar("client_binding_digest", { length: 71 }),
+    installationId: varchar("installation_id", { length: 160 }),
+    hostSessionDigest: varchar("host_session_digest", { length: 71 }),
+    clientSessionId: varchar("client_session_id", { length: 80 }).references(
+      () => clientAgentSessions.sessionId,
+      { onDelete: "restrict" },
+    ),
+    claimTokenHash: varchar("claim_token_hash", { length: 71 }),
+    claimExpiresAt: doublePrecision("claim_expires_at"),
+    historySequence: integer("history_sequence").notNull().default(0),
+    historyHeadDigest: varchar("history_head_digest", { length: 71 }),
+    terminalReceiptId: varchar("terminal_receipt_id", { length: 96 }),
+    terminalReceiptDigest: varchar("terminal_receipt_digest", { length: 71 }),
+    terminalRequestDigest: varchar("terminal_request_digest", { length: 71 }),
+    terminalResultJson: jsonb("terminal_result_json").$type<
+      Record<string, unknown>
+    >(),
+    artifactRef: varchar("artifact_ref", { length: 37 }),
+    artifactFilename: varchar("artifact_filename", { length: 240 }),
+    artifactContentType: varchar("artifact_content_type", { length: 120 }),
+    artifactByteSize: integer("artifact_byte_size"),
+    artifactSha256: varchar("artifact_sha256", { length: 64 }),
+    cancelRequestedAt: doublePrecision("cancel_requested_at"),
+    finishedAt: doublePrecision("finished_at"),
+    version: integer("version").notNull().default(1),
+    createdAt: doublePrecision("created_at").notNull(),
+    updatedAt: doublePrecision("updated_at").notNull(),
+  },
+  (table) => [
+    uniqueIndex("uk_client_agent_workflow_command").on(table.commandId),
+    uniqueIndex("uk_client_agent_workflow_job").on(table.durableJobId),
+    uniqueIndex("uk_client_agent_workflow_terminal_receipt").on(
+      table.terminalReceiptId,
+    ),
+    uniqueIndex("uk_client_agent_workflow_client_session").on(
+      table.clientSessionId,
+    ),
+    index("idx_client_agent_workflow_claim").on(
+      table.actorId,
+      table.status,
+      table.updatedAt,
+    ),
+    index("idx_client_agent_workflow_host").on(
+      table.hostSessionDigest,
+      table.status,
+    ),
+    foreignKey({
+      columns: [
+        table.commandId,
+        table.runId,
+        table.nodeRunId,
+        table.effectKind,
+        table.effectGeneration,
+        table.requestDigest,
+        table.effectFenceTokenDigest,
+      ],
+      foreignColumns: [
+        agentWorkflowSideEffectCommands.commandId,
+        agentWorkflowSideEffectCommands.runId,
+        agentWorkflowSideEffectCommands.nodeRunId,
+        agentWorkflowSideEffectCommands.effectKind,
+        agentWorkflowSideEffectCommands.generation,
+        agentWorkflowSideEffectCommands.requestDigest,
+        agentWorkflowSideEffectCommands.fenceTokenDigest,
+      ],
+      name: "fk_client_agent_workflow_effect_fence",
+    }).onDelete("restrict"),
+    check(
+      "ck_client_agent_workflow_status",
+      sql`${table.status} in ('pending', 'claimed', 'cancellation-requested', 'completed', 'cancelled')`,
+    ),
+    check(
+      "ck_client_agent_workflow_generation",
+      sql`${table.effectGeneration} > 0 and ${table.claimGeneration} >= 0`,
+    ),
+    check(
+      "ck_client_agent_workflow_effect_kind",
+      sql`${table.effectKind} = 'job'`,
+    ),
+    check(
+      "ck_client_agent_workflow_claim_binding",
+      sql`(${table.claimGeneration} = 0 and ${table.status} in ('pending', 'cancellation-requested', 'cancelled') and ${table.clientBindingDigest} is null and ${table.installationId} is null and ${table.hostSessionDigest} is null and ${table.clientSessionId} is null and ${table.claimTokenHash} is null and ${table.claimExpiresAt} is null)
+        or (${table.claimGeneration} > 0 and ${table.status} <> 'pending' and ${table.clientBindingDigest} is not null and ${table.installationId} is not null and ${table.hostSessionDigest} is not null)`,
+    ),
+    check(
+      "ck_client_agent_workflow_terminal",
+      sql`(${table.status} = 'completed' and ${table.terminalReceiptId} is not null and ${table.terminalReceiptDigest} is not null and ${table.terminalRequestDigest} is not null and ${table.terminalResultJson} is not null and ${table.artifactRef} is not null and ${table.artifactFilename} is not null and ${table.artifactContentType} is not null and ${table.artifactByteSize} is not null and ${table.artifactSha256} is not null and ${table.finishedAt} is not null)
+        or (${table.status} = 'cancelled' and ${table.finishedAt} is not null and ${table.terminalReceiptId} is null and ${table.terminalRequestDigest} is null and ${table.artifactRef} is null)
+        or (${table.status} in ('pending', 'claimed', 'cancellation-requested') and ${table.finishedAt} is null and ${table.terminalReceiptId} is null and ${table.terminalRequestDigest} is null and ${table.artifactRef} is null)`,
+    ),
+    check(
+      "ck_client_agent_workflow_history",
+      sql`${table.historySequence} >= 0 and (${table.historySequence} = 0 or ${table.historyHeadDigest} is not null)`,
+    ),
+    check(
+      "ck_client_agent_workflow_version",
+      sql`${table.version} > 0 and ${table.createdAt} <= ${table.updatedAt}`,
+    ),
+  ],
+);

package/template/packages/database/src/schema/client-agent.ts

@@ -0,0 +1,95 @@
+import { sql } from "drizzle-orm";
+import {
+  check,
+  doublePrecision,
+  index,
+  integer,
+  jsonb,
+  pgTable,
+  uniqueIndex,
+  varchar,
+} from "drizzle-orm/pg-core";
+
+export const clientAgentSessions = pgTable(
+  "client_agent_sessions",
+  {
+    sessionId: varchar("session_id", { length: 80 }).primaryKey(),
+    clientRunId: varchar("client_run_id", { length: 80 }).notNull(),
+    actorId: varchar("actor_id", { length: 64 }).notNull(),
+    operationKey: varchar("operation_key", { length: 200 }).notNull(),
+    releaseId: varchar("release_id", { length: 80 }).notNull(),
+    tokenHash: varchar("token_hash", { length: 71 }).notNull(),
+    clientBindingDigest: varchar("client_binding_digest", {
+      length: 71,
+    }).notNull(),
+    hostSessionDigest: varchar("host_session_digest", {
+      length: 71,
+    }).notNull(),
+    modelAlias: varchar("model_alias", { length: 80 }).notNull(),
+    status: varchar("status", { length: 24 }).notNull(),
+    attemptCount: integer("attempt_count").notNull().default(0),
+    activeRequests: integer("active_requests").notNull().default(0),
+    pendingAttempts: jsonb("pending_attempts").$type<number[]>().notNull(),
+    admissionJson: jsonb("admission_json")
+      .$type<Record<string, unknown>>()
+      .notNull(),
+    terminalDigest: varchar("terminal_digest", { length: 71 }),
+    finalResultJson:
+      jsonb("final_result_json").$type<Record<string, unknown>>(),
+    createdAt: doublePrecision("created_at").notNull(),
+    expiresAt: doublePrecision("expires_at").notNull(),
+  },
+  (table) => [
+    uniqueIndex("uk_client_agent_sessions_run").on(table.clientRunId),
+    uniqueIndex("uk_client_agent_sessions_token").on(table.tokenHash),
+    index("idx_client_agent_sessions_actor").on(table.actorId, table.status),
+    index("idx_client_agent_sessions_binding").on(
+      table.clientBindingDigest,
+      table.status,
+    ),
+    index("idx_client_agent_sessions_host").on(
+      table.hostSessionDigest,
+      table.status,
+    ),
+    index("idx_client_agent_sessions_expiry").on(table.status, table.expiresAt),
+    check(
+      "ck_client_agent_sessions_status",
+      sql`${table.status} in ('active', 'completed', 'cancelled', 'revoked', 'expired')`,
+    ),
+    check(
+      "ck_client_agent_sessions_attempts",
+      sql`${table.attemptCount} >= 0 and ${table.activeRequests} >= 0`,
+    ),
+  ],
+);
+
+export const clientAgentReceipts = pgTable(
+  "client_agent_receipts",
+  {
+    receiptId: varchar("receipt_id", { length: 80 }).primaryKey(),
+    sessionId: varchar("session_id", { length: 80 })
+      .notNull()
+      .references(() => clientAgentSessions.sessionId, { onDelete: "cascade" }),
+    clientRunId: varchar("client_run_id", { length: 80 }).notNull(),
+    actorId: varchar("actor_id", { length: 64 }).notNull(),
+    operationKey: varchar("operation_key", { length: 200 }).notNull(),
+    releaseId: varchar("release_id", { length: 80 }).notNull(),
+    clientBindingDigest: varchar("client_binding_digest", {
+      length: 71,
+    }).notNull(),
+    attempt: integer("attempt").notNull(),
+    requestDigest: varchar("request_digest", { length: 71 }).notNull(),
+    responseDigest: varchar("response_digest", { length: 71 }).notNull(),
+    deploymentDigest: varchar("deployment_digest", { length: 71 }).notNull(),
+    canonicalResultJson: jsonb("canonical_result_json"),
+    issuedAt: doublePrecision("issued_at").notNull(),
+  },
+  (table) => [
+    uniqueIndex("uk_client_agent_receipts_attempt").on(
+      table.sessionId,
+      table.attempt,
+    ),
+    index("idx_client_agent_receipts_run").on(table.clientRunId, table.attempt),
+    check("ck_client_agent_receipts_attempt", sql`${table.attempt} > 0`),
+  ],
+);

package/template/packages/database/src/schema/index.ts

@@ -31,6 +31,15 @@ export * from "./workflow.js";
 // @windy-module system.workflow end
 // @windy-module system.agent begin
 export * from "./agent-runtime.js";
+export * from "./agent-workflow.js";
+export * from "./agent-workflow-delegation.js";
+export * from "./agent-workflow-effects.js";
+export * from "./agent-workflow-evaluation.js";
+export * from "./agent-context-message.js";
+export * from "./agent-session-receipt.js";
+export * from "./agent-session.js";
+export * from "./client-agent.js";
+export * from "./client-agent-workflow-artifact.js";
 export * from "./embedding-runtime.js";
 export * from "./ai-output-artifacts.js";
 // @windy-module system.agent end

package/template/packages/jobs/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@southwind-ai/jobs",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "license": "UNLICENSED",
   "type": "module",
   "engines": {

package/template/packages/jobs/src/handlers.test.ts

@@ -81,5 +81,15 @@ function createContext(): DurableHandlerContext {
     heartbeat: async () => undefined,
     progress: async () => undefined,
     publishArtifact: async () => undefined,
+    publishArtifactOnce: async (publicationKey, artifact) => ({
+      schemaVersion: 1,
+      publicationKey,
+      artifactId: "dap_stable",
+      jobId: "job-1",
+      stageKey: "main",
+      kind: artifact.kind,
+      artifactRef: artifact.artifactRef,
+      sha256: artifact.sha256,
+    }),
   };
 }