weave-typescript 0.42.8 → 0.44.0

package/dist/weavesql/weavedb/workflow_sql.js

@@ -1,38 +1,55 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.listWorkflowStageStatesQuery = exports.getWorkflowStageStateQuery = exports.upsertWorkflowStageStateQuery = exports.deleteWorkflowQuery = exports.archiveWorkflowQuery = exports.updateWorkflowQuery = exports.listWorkflowsByProjectQuery = exports.getWorkflowBySlugQuery = exports.getWorkflowQuery = exports.createWorkflowQuery = void 0;
-exports.createWorkflow = createWorkflow;
-exports.getWorkflow = getWorkflow;
-exports.getWorkflowBySlug = getWorkflowBySlug;
-exports.listWorkflowsByProject = listWorkflowsByProject;
-exports.updateWorkflow = updateWorkflow;
-exports.archiveWorkflow = archiveWorkflow;
-exports.deleteWorkflow = deleteWorkflow;
-exports.upsertWorkflowStageState = upsertWorkflowStageState;
-exports.getWorkflowStageState = getWorkflowStageState;
-exports.listWorkflowStageStates = listWorkflowStageStates;
-exports.createWorkflowQuery = `-- name: CreateWorkflow :one
-INSERT INTO weave_v1.workflow (
+exports.listToolCallEventsQuery = exports.insertToolCallEventQuery = exports.listWorkflowRunEventsQuery = exports.insertWorkflowRunEventQuery = exports.updateWorkflowStepRunStatusQuery = exports.listWorkflowStepRunsQuery = exports.createWorkflowStepRunQuery = exports.updateWorkflowRunStatusQuery = exports.listWorkflowRunsQuery = exports.getWorkflowRunQuery = exports.createWorkflowRunQuery = exports.listWorkflowTemplateVersionsQuery = exports.getWorkflowTemplateVersionByIDQuery = exports.getWorkflowTemplateVersionByNumberQuery = exports.setWorkflowTemplateLatestVersionQuery = exports.insertWorkflowTemplateVersionQuery = exports.insertWorkflowDraftPatchQuery = exports.updateWorkflowDraftQuery = exports.updateWorkflowTemplateStatusQuery = exports.updateWorkflowTemplateDraftMetadataQuery = exports.listWorkflowTemplatesQuery = exports.getWorkflowTemplateDraftQuery = exports.getWorkflowTemplateBySlugQuery = exports.getWorkflowTemplateByIDQuery = exports.createWorkflowTemplateDraftQuery = exports.createWorkflowTemplateQuery = void 0;
+exports.createWorkflowTemplate = createWorkflowTemplate;
+exports.createWorkflowTemplateDraft = createWorkflowTemplateDraft;
+exports.getWorkflowTemplateByID = getWorkflowTemplateByID;
+exports.getWorkflowTemplateBySlug = getWorkflowTemplateBySlug;
+exports.getWorkflowTemplateDraft = getWorkflowTemplateDraft;
+exports.listWorkflowTemplates = listWorkflowTemplates;
+exports.updateWorkflowTemplateDraftMetadata = updateWorkflowTemplateDraftMetadata;
+exports.updateWorkflowTemplateStatus = updateWorkflowTemplateStatus;
+exports.updateWorkflowDraft = updateWorkflowDraft;
+exports.insertWorkflowDraftPatch = insertWorkflowDraftPatch;
+exports.insertWorkflowTemplateVersion = insertWorkflowTemplateVersion;
+exports.setWorkflowTemplateLatestVersion = setWorkflowTemplateLatestVersion;
+exports.getWorkflowTemplateVersionByNumber = getWorkflowTemplateVersionByNumber;
+exports.getWorkflowTemplateVersionByID = getWorkflowTemplateVersionByID;
+exports.listWorkflowTemplateVersions = listWorkflowTemplateVersions;
+exports.createWorkflowRun = createWorkflowRun;
+exports.getWorkflowRun = getWorkflowRun;
+exports.listWorkflowRuns = listWorkflowRuns;
+exports.updateWorkflowRunStatus = updateWorkflowRunStatus;
+exports.createWorkflowStepRun = createWorkflowStepRun;
+exports.listWorkflowStepRuns = listWorkflowStepRuns;
+exports.updateWorkflowStepRunStatus = updateWorkflowStepRunStatus;
+exports.insertWorkflowRunEvent = insertWorkflowRunEvent;
+exports.listWorkflowRunEvents = listWorkflowRunEvents;
+exports.insertToolCallEvent = insertToolCallEvent;
+exports.listToolCallEvents = listToolCallEvents;
+exports.createWorkflowTemplateQuery = `-- name: CreateWorkflowTemplate :one
+INSERT INTO weave.workflow_templates (
     id,
-    project_id,
-    name,
+    organization_id,
     slug,
+    name,
     description,
-    status
-)
-VALUES (
+    status,
+    created_by_user_id
+) VALUES (
     $1,
     $2,
     $3,
     $4,
     $5,
-    $6
+    $6,
+    $7
 )
-RETURNING id, project_id, name, slug, description, status, created_at, updated_at, archived_at`;
-async function createWorkflow(client, args) {
+RETURNING id, organization_id, slug, name, description, status, created_by_user_id, draft_revision, latest_version_id, latest_version, created_at, updated_at`;
+async function createWorkflowTemplate(client, args) {
     const result = await client.query({
-        text: exports.createWorkflowQuery,
-        values: [args.id, args.projectId, args.name, args.slug, args.description, args.status],
+        text: exports.createWorkflowTemplateQuery,
+        values: [args.id, args.organizationId, args.slug, args.name, args.description, args.status, args.createdByUserId],
         rowMode: "array"
     });
     if (result.rows.length !== 1) {
@@ -41,25 +58,83 @@ async function createWorkflow(client, args) {
     const row = result.rows[0];
     return {
         id: row[0],
-        projectId: row[1],
-        name: row[2],
-        slug: row[3],
+        organizationId: row[1],
+        slug: row[2],
+        name: row[3],
         description: row[4],
         status: row[5],
-        createdAt: row[6],
-        updatedAt: row[7],
-        archivedAt: row[8]
+        createdByUserId: row[6],
+        draftRevision: row[7],
+        latestVersionId: row[8],
+        latestVersion: row[9],
+        createdAt: row[10],
+        updatedAt: row[11]
+    };
+}
+exports.createWorkflowTemplateDraftQuery = `-- name: CreateWorkflowTemplateDraft :one
+INSERT INTO weave.workflow_template_drafts (
+    id,
+    template_id,
+    organization_id,
+    base_version_id,
+    revision,
+    name,
+    description,
+    definition,
+    input_schema,
+    output_schema,
+    metadata,
+    updated_by_user_id
+) VALUES (
+    $1,
+    $2,
+    $3,
+    $4::uuid,
+    $5,
+    $6,
+    $7,
+    $8,
+    $9,
+    $10,
+    $11,
+    $12
+)
+RETURNING id, template_id, organization_id, base_version_id, revision, name, description, definition, input_schema, output_schema, metadata, updated_by_user_id, created_at, updated_at`;
+async function createWorkflowTemplateDraft(client, args) {
+    const result = await client.query({
+        text: exports.createWorkflowTemplateDraftQuery,
+        values: [args.id, args.templateId, args.organizationId, args.baseVersionId, args.revision, args.name, args.description, args.definition, args.inputSchema, args.outputSchema, args.metadata, args.updatedByUserId],
+        rowMode: "array"
+    });
+    if (result.rows.length !== 1) {
+        return null;
+    }
+    const row = result.rows[0];
+    return {
+        id: row[0],
+        templateId: row[1],
+        organizationId: row[2],
+        baseVersionId: row[3],
+        revision: row[4],
+        name: row[5],
+        description: row[6],
+        definition: row[7],
+        inputSchema: row[8],
+        outputSchema: row[9],
+        metadata: row[10],
+        updatedByUserId: row[11],
+        createdAt: row[12],
+        updatedAt: row[13]
     };
 }
-exports.getWorkflowQuery = `-- name: GetWorkflow :one
-SELECT id, project_id, name, slug, description, status, created_at, updated_at, archived_at
-FROM weave_v1.workflow
-WHERE id = $1
-  AND project_id = $2`;
-async function getWorkflow(client, args) {
+exports.getWorkflowTemplateByIDQuery = `-- name: GetWorkflowTemplateByID :one
+SELECT id, organization_id, slug, name, description, status, created_by_user_id, draft_revision, latest_version_id, latest_version, created_at, updated_at FROM weave.workflow_templates
+WHERE organization_id = $1
+  AND id = $2`;
+async function getWorkflowTemplateByID(client, args) {
     const result = await client.query({
-        text: exports.getWorkflowQuery,
-        values: [args.id, args.projectId],
+        text: exports.getWorkflowTemplateByIDQuery,
+        values: [args.organizationId, args.templateId],
         rowMode: "array"
     });
     if (result.rows.length !== 1) {
@@ -68,27 +143,27 @@ async function getWorkflow(client, args) {
     const row = result.rows[0];
     return {
         id: row[0],
-        projectId: row[1],
-        name: row[2],
-        slug: row[3],
+        organizationId: row[1],
+        slug: row[2],
+        name: row[3],
         description: row[4],
         status: row[5],
-        createdAt: row[6],
-        updatedAt: row[7],
-        archivedAt: row[8]
+        createdByUserId: row[6],
+        draftRevision: row[7],
+        latestVersionId: row[8],
+        latestVersion: row[9],
+        createdAt: row[10],
+        updatedAt: row[11]
     };
 }
-exports.getWorkflowBySlugQuery = `-- name: GetWorkflowBySlug :one
-SELECT w.id, w.project_id, w.name, w.slug, w.description, w.status, w.created_at, w.updated_at, w.archived_at
-FROM weave_v1.workflow w
-         INNER JOIN weave_v1.project p ON p.id = w.project_id
-WHERE p.organization_id = $1
-  AND p.slug = $2
-  AND w.slug = $3`;
-async function getWorkflowBySlug(client, args) {
+exports.getWorkflowTemplateBySlugQuery = `-- name: GetWorkflowTemplateBySlug :one
+SELECT id, organization_id, slug, name, description, status, created_by_user_id, draft_revision, latest_version_id, latest_version, created_at, updated_at FROM weave.workflow_templates
+WHERE organization_id = $1
+  AND slug = $2`;
+async function getWorkflowTemplateBySlug(client, args) {
     const result = await client.query({
-        text: exports.getWorkflowBySlugQuery,
-        values: [args.organizationId, args.projectSlug, args.slug],
+        text: exports.getWorkflowTemplateBySlugQuery,
+        values: [args.organizationId, args.slug],
         rowMode: "array"
     });
     if (result.rows.length !== 1) {
@@ -97,58 +172,96 @@ async function getWorkflowBySlug(client, args) {
     const row = result.rows[0];
     return {
         id: row[0],
-        projectId: row[1],
-        name: row[2],
-        slug: row[3],
+        organizationId: row[1],
+        slug: row[2],
+        name: row[3],
         description: row[4],
         status: row[5],
-        createdAt: row[6],
-        updatedAt: row[7],
-        archivedAt: row[8]
+        createdByUserId: row[6],
+        draftRevision: row[7],
+        latestVersionId: row[8],
+        latestVersion: row[9],
+        createdAt: row[10],
+        updatedAt: row[11]
     };
 }
-exports.listWorkflowsByProjectQuery = `-- name: ListWorkflowsByProject :many
-SELECT id, project_id, name, slug, description, status, created_at, updated_at, archived_at
-FROM weave_v1.workflow
-WHERE project_id = $1
-  AND ($2::BOOLEAN OR archived_at IS NULL)
-ORDER BY updated_at DESC
-LIMIT $4
-OFFSET $3`;
-async function listWorkflowsByProject(client, args) {
+exports.getWorkflowTemplateDraftQuery = `-- name: GetWorkflowTemplateDraft :one
+SELECT id, template_id, organization_id, base_version_id, revision, name, description, definition, input_schema, output_schema, metadata, updated_by_user_id, created_at, updated_at FROM weave.workflow_template_drafts
+WHERE organization_id = $1
+  AND template_id = $2`;
+async function getWorkflowTemplateDraft(client, args) {
     const result = await client.query({
-        text: exports.listWorkflowsByProjectQuery,
-        values: [args.projectId, args.includeArchived, args.pageOffset, args.pageSize],
+        text: exports.getWorkflowTemplateDraftQuery,
+        values: [args.organizationId, args.templateId],
+        rowMode: "array"
+    });
+    if (result.rows.length !== 1) {
+        return null;
+    }
+    const row = result.rows[0];
+    return {
+        id: row[0],
+        templateId: row[1],
+        organizationId: row[2],
+        baseVersionId: row[3],
+        revision: row[4],
+        name: row[5],
+        description: row[6],
+        definition: row[7],
+        inputSchema: row[8],
+        outputSchema: row[9],
+        metadata: row[10],
+        updatedByUserId: row[11],
+        createdAt: row[12],
+        updatedAt: row[13]
+    };
+}
+exports.listWorkflowTemplatesQuery = `-- name: ListWorkflowTemplates :many
+SELECT id, organization_id, slug, name, description, status, created_by_user_id, draft_revision, latest_version_id, latest_version, created_at, updated_at FROM weave.workflow_templates
+WHERE organization_id = $1
+  AND (
+      $2::text IS NULL
+      OR status = $2::text
+  )
+ORDER BY updated_at DESC, created_at DESC
+LIMIT $4 OFFSET $3`;
+async function listWorkflowTemplates(client, args) {
+    const result = await client.query({
+        text: exports.listWorkflowTemplatesQuery,
+        values: [args.organizationId, args.status, args.pageOffset, args.pageSize],
         rowMode: "array"
     });
     return result.rows.map(row => {
         return {
             id: row[0],
-            projectId: row[1],
-            name: row[2],
-            slug: row[3],
+            organizationId: row[1],
+            slug: row[2],
+            name: row[3],
             description: row[4],
             status: row[5],
-            createdAt: row[6],
-            updatedAt: row[7],
-            archivedAt: row[8]
+            createdByUserId: row[6],
+            draftRevision: row[7],
+            latestVersionId: row[8],
+            latestVersion: row[9],
+            createdAt: row[10],
+            updatedAt: row[11]
         };
     });
 }
-exports.updateWorkflowQuery = `-- name: UpdateWorkflow :one
-UPDATE weave_v1.workflow
-SET name = $1,
-    slug = $2,
-    description = $3,
-    status = $4,
-    updated_at = NOW()
-WHERE id = $5
-  AND project_id = $6
-RETURNING id, project_id, name, slug, description, status, created_at, updated_at, archived_at`;
-async function updateWorkflow(client, args) {
+exports.updateWorkflowTemplateDraftMetadataQuery = `-- name: UpdateWorkflowTemplateDraftMetadata :one
+UPDATE weave.workflow_templates
+SET
+    name = $1,
+    description = $2,
+    draft_revision = $3,
+    updated_at = now()
+WHERE organization_id = $4
+  AND id = $5
+RETURNING id, organization_id, slug, name, description, status, created_by_user_id, draft_revision, latest_version_id, latest_version, created_at, updated_at`;
+async function updateWorkflowTemplateDraftMetadata(client, args) {
     const result = await client.query({
-        text: exports.updateWorkflowQuery,
-        values: [args.name, args.slug, args.description, args.status, args.id, args.projectId],
+        text: exports.updateWorkflowTemplateDraftMetadataQuery,
+        values: [args.name, args.description, args.draftRevision, args.organizationId, args.templateId],
         rowMode: "array"
     });
     if (result.rows.length !== 1) {
@@ -157,28 +270,166 @@ async function updateWorkflow(client, args) {
     const row = result.rows[0];
     return {
         id: row[0],
-        projectId: row[1],
-        name: row[2],
-        slug: row[3],
+        organizationId: row[1],
+        slug: row[2],
+        name: row[3],
         description: row[4],
         status: row[5],
-        createdAt: row[6],
-        updatedAt: row[7],
-        archivedAt: row[8]
+        createdByUserId: row[6],
+        draftRevision: row[7],
+        latestVersionId: row[8],
+        latestVersion: row[9],
+        createdAt: row[10],
+        updatedAt: row[11]
+    };
+}
+exports.updateWorkflowTemplateStatusQuery = `-- name: UpdateWorkflowTemplateStatus :one
+UPDATE weave.workflow_templates
+SET
+    status = $1,
+    updated_at = now()
+WHERE organization_id = $2
+  AND id = $3
+RETURNING id, organization_id, slug, name, description, status, created_by_user_id, draft_revision, latest_version_id, latest_version, created_at, updated_at`;
+async function updateWorkflowTemplateStatus(client, args) {
+    const result = await client.query({
+        text: exports.updateWorkflowTemplateStatusQuery,
+        values: [args.status, args.organizationId, args.templateId],
+        rowMode: "array"
+    });
+    if (result.rows.length !== 1) {
+        return null;
+    }
+    const row = result.rows[0];
+    return {
+        id: row[0],
+        organizationId: row[1],
+        slug: row[2],
+        name: row[3],
+        description: row[4],
+        status: row[5],
+        createdByUserId: row[6],
+        draftRevision: row[7],
+        latestVersionId: row[8],
+        latestVersion: row[9],
+        createdAt: row[10],
+        updatedAt: row[11]
+    };
+}
+exports.updateWorkflowDraftQuery = `-- name: UpdateWorkflowDraft :one
+UPDATE weave.workflow_template_drafts
+SET
+    base_version_id = $1::uuid,
+    revision = revision + 1,
+    name = $2,
+    description = $3,
+    definition = $4,
+    input_schema = $5,
+    output_schema = $6,
+    metadata = $7,
+    updated_by_user_id = $8,
+    updated_at = now()
+WHERE organization_id = $9
+  AND template_id = $10
+  AND revision = $11
+RETURNING id, template_id, organization_id, base_version_id, revision, name, description, definition, input_schema, output_schema, metadata, updated_by_user_id, created_at, updated_at`;
+async function updateWorkflowDraft(client, args) {
+    const result = await client.query({
+        text: exports.updateWorkflowDraftQuery,
+        values: [args.baseVersionId, args.name, args.description, args.definition, args.inputSchema, args.outputSchema, args.metadata, args.updatedByUserId, args.organizationId, args.templateId, args.expectedRevision],
+        rowMode: "array"
+    });
+    if (result.rows.length !== 1) {
+        return null;
+    }
+    const row = result.rows[0];
+    return {
+        id: row[0],
+        templateId: row[1],
+        organizationId: row[2],
+        baseVersionId: row[3],
+        revision: row[4],
+        name: row[5],
+        description: row[6],
+        definition: row[7],
+        inputSchema: row[8],
+        outputSchema: row[9],
+        metadata: row[10],
+        updatedByUserId: row[11],
+        createdAt: row[12],
+        updatedAt: row[13]
+    };
+}
+exports.insertWorkflowDraftPatchQuery = `-- name: InsertWorkflowDraftPatch :one
+INSERT INTO weave.workflow_template_draft_patches (
+    id,
+    template_id,
+    organization_id,
+    revision,
+    patch,
+    created_by_user_id
+) VALUES (
+    $1,
+    $2,
+    $3,
+    $4,
+    $5,
+    $6
+)
+RETURNING id, template_id, organization_id, revision, patch, created_by_user_id, created_at`;
+async function insertWorkflowDraftPatch(client, args) {
+    const result = await client.query({
+        text: exports.insertWorkflowDraftPatchQuery,
+        values: [args.id, args.templateId, args.organizationId, args.revision, args.patch, args.createdByUserId],
+        rowMode: "array"
+    });
+    if (result.rows.length !== 1) {
+        return null;
+    }
+    const row = result.rows[0];
+    return {
+        id: row[0],
+        templateId: row[1],
+        organizationId: row[2],
+        revision: row[3],
+        patch: row[4],
+        createdByUserId: row[5],
+        createdAt: row[6]
     };
 }
-exports.archiveWorkflowQuery = `-- name: ArchiveWorkflow :one
-UPDATE weave_v1.workflow
-SET status = 'archived',
-    archived_at = NOW(),
-    updated_at = NOW()
-WHERE id = $1
-  AND project_id = $2
-RETURNING id, project_id, name, slug, description, status, created_at, updated_at, archived_at`;
-async function archiveWorkflow(client, args) {
+exports.insertWorkflowTemplateVersionQuery = `-- name: InsertWorkflowTemplateVersion :one
+INSERT INTO weave.workflow_template_versions (
+    id,
+    template_id,
+    organization_id,
+    version,
+    source_draft_revision,
+    name,
+    description,
+    definition,
+    input_schema,
+    output_schema,
+    metadata,
+    published_by_user_id
+) VALUES (
+    $1,
+    $2,
+    $3,
+    $4,
+    $5,
+    $6,
+    $7,
+    $8,
+    $9,
+    $10,
+    $11,
+    $12
+)
+RETURNING id, template_id, organization_id, version, source_draft_revision, name, description, definition, input_schema, output_schema, metadata, published_by_user_id, published_at`;
+async function insertWorkflowTemplateVersion(client, args) {
     const result = await client.query({
-        text: exports.archiveWorkflowQuery,
-        values: [args.id, args.projectId],
+        text: exports.insertWorkflowTemplateVersionQuery,
+        values: [args.id, args.templateId, args.organizationId, args.version, args.sourceDraftRevision, args.name, args.description, args.definition, args.inputSchema, args.outputSchema, args.metadata, args.publishedByUserId],
         rowMode: "array"
     });
     if (result.rows.length !== 1) {
@@ -187,53 +438,326 @@ async function archiveWorkflow(client, args) {
     const row = result.rows[0];
     return {
         id: row[0],
-        projectId: row[1],
-        name: row[2],
-        slug: row[3],
+        templateId: row[1],
+        organizationId: row[2],
+        version: row[3],
+        sourceDraftRevision: row[4],
+        name: row[5],
+        description: row[6],
+        definition: row[7],
+        inputSchema: row[8],
+        outputSchema: row[9],
+        metadata: row[10],
+        publishedByUserId: row[11],
+        publishedAt: row[12]
+    };
+}
+exports.setWorkflowTemplateLatestVersionQuery = `-- name: SetWorkflowTemplateLatestVersion :one
+UPDATE weave.workflow_templates
+SET
+    latest_version_id = $1,
+    latest_version = $2,
+    updated_at = now()
+WHERE organization_id = $3
+  AND id = $4
+RETURNING id, organization_id, slug, name, description, status, created_by_user_id, draft_revision, latest_version_id, latest_version, created_at, updated_at`;
+async function setWorkflowTemplateLatestVersion(client, args) {
+    const result = await client.query({
+        text: exports.setWorkflowTemplateLatestVersionQuery,
+        values: [args.versionId, args.version, args.organizationId, args.templateId],
+        rowMode: "array"
+    });
+    if (result.rows.length !== 1) {
+        return null;
+    }
+    const row = result.rows[0];
+    return {
+        id: row[0],
+        organizationId: row[1],
+        slug: row[2],
+        name: row[3],
         description: row[4],
         status: row[5],
-        createdAt: row[6],
-        updatedAt: row[7],
-        archivedAt: row[8]
+        createdByUserId: row[6],
+        draftRevision: row[7],
+        latestVersionId: row[8],
+        latestVersion: row[9],
+        createdAt: row[10],
+        updatedAt: row[11]
+    };
+}
+exports.getWorkflowTemplateVersionByNumberQuery = `-- name: GetWorkflowTemplateVersionByNumber :one
+SELECT id, template_id, organization_id, version, source_draft_revision, name, description, definition, input_schema, output_schema, metadata, published_by_user_id, published_at FROM weave.workflow_template_versions
+WHERE organization_id = $1
+  AND template_id = $2
+  AND version = $3`;
+async function getWorkflowTemplateVersionByNumber(client, args) {
+    const result = await client.query({
+        text: exports.getWorkflowTemplateVersionByNumberQuery,
+        values: [args.organizationId, args.templateId, args.version],
+        rowMode: "array"
+    });
+    if (result.rows.length !== 1) {
+        return null;
+    }
+    const row = result.rows[0];
+    return {
+        id: row[0],
+        templateId: row[1],
+        organizationId: row[2],
+        version: row[3],
+        sourceDraftRevision: row[4],
+        name: row[5],
+        description: row[6],
+        definition: row[7],
+        inputSchema: row[8],
+        outputSchema: row[9],
+        metadata: row[10],
+        publishedByUserId: row[11],
+        publishedAt: row[12]
+    };
+}
+exports.getWorkflowTemplateVersionByIDQuery = `-- name: GetWorkflowTemplateVersionByID :one
+SELECT id, template_id, organization_id, version, source_draft_revision, name, description, definition, input_schema, output_schema, metadata, published_by_user_id, published_at FROM weave.workflow_template_versions
+WHERE organization_id = $1
+  AND id = $2`;
+async function getWorkflowTemplateVersionByID(client, args) {
+    const result = await client.query({
+        text: exports.getWorkflowTemplateVersionByIDQuery,
+        values: [args.organizationId, args.versionId],
+        rowMode: "array"
+    });
+    if (result.rows.length !== 1) {
+        return null;
+    }
+    const row = result.rows[0];
+    return {
+        id: row[0],
+        templateId: row[1],
+        organizationId: row[2],
+        version: row[3],
+        sourceDraftRevision: row[4],
+        name: row[5],
+        description: row[6],
+        definition: row[7],
+        inputSchema: row[8],
+        outputSchema: row[9],
+        metadata: row[10],
+        publishedByUserId: row[11],
+        publishedAt: row[12]
     };
 }
-exports.deleteWorkflowQuery = `-- name: DeleteWorkflow :exec
-DELETE
-FROM weave_v1.workflow
-WHERE id = $1
-  AND project_id = $2`;
-async function deleteWorkflow(client, args) {
-    await client.query({
-        text: exports.deleteWorkflowQuery,
-        values: [args.id, args.projectId],
+exports.listWorkflowTemplateVersionsQuery = `-- name: ListWorkflowTemplateVersions :many
+SELECT id, template_id, organization_id, version, source_draft_revision, name, description, definition, input_schema, output_schema, metadata, published_by_user_id, published_at FROM weave.workflow_template_versions
+WHERE organization_id = $1
+  AND template_id = $2
+ORDER BY version DESC
+LIMIT $4 OFFSET $3`;
+async function listWorkflowTemplateVersions(client, args) {
+    const result = await client.query({
+        text: exports.listWorkflowTemplateVersionsQuery,
+        values: [args.organizationId, args.templateId, args.pageOffset, args.pageSize],
+        rowMode: "array"
+    });
+    return result.rows.map(row => {
+        return {
+            id: row[0],
+            templateId: row[1],
+            organizationId: row[2],
+            version: row[3],
+            sourceDraftRevision: row[4],
+            name: row[5],
+            description: row[6],
+            definition: row[7],
+            inputSchema: row[8],
+            outputSchema: row[9],
+            metadata: row[10],
+            publishedByUserId: row[11],
+            publishedAt: row[12]
+        };
+    });
+}
+exports.createWorkflowRunQuery = `-- name: CreateWorkflowRun :one
+INSERT INTO weave.workflow_runs (
+    id,
+    organization_id,
+    workflow_template_id,
+    workflow_version_id,
+    status,
+    created_by_user_id,
+    chat_session_id,
+    input
+) VALUES (
+    $1,
+    $2,
+    $3,
+    $4,
+    $5,
+    $6,
+    $7::uuid,
+    $8
+)
+RETURNING id, organization_id, workflow_template_id, workflow_version_id, status, created_by_user_id, chat_session_id, input, output, error_code, safe_error_message, created_at, started_at, finished_at`;
+async function createWorkflowRun(client, args) {
+    const result = await client.query({
+        text: exports.createWorkflowRunQuery,
+        values: [args.id, args.organizationId, args.workflowTemplateId, args.workflowVersionId, args.status, args.createdByUserId, args.chatSessionId, args.input],
         rowMode: "array"
     });
+    if (result.rows.length !== 1) {
+        return null;
+    }
+    const row = result.rows[0];
+    return {
+        id: row[0],
+        organizationId: row[1],
+        workflowTemplateId: row[2],
+        workflowVersionId: row[3],
+        status: row[4],
+        createdByUserId: row[5],
+        chatSessionId: row[6],
+        input: row[7],
+        output: row[8],
+        errorCode: row[9],
+        safeErrorMessage: row[10],
+        createdAt: row[11],
+        startedAt: row[12],
+        finishedAt: row[13]
+    };
+}
+exports.getWorkflowRunQuery = `-- name: GetWorkflowRun :one
+SELECT id, organization_id, workflow_template_id, workflow_version_id, status, created_by_user_id, chat_session_id, input, output, error_code, safe_error_message, created_at, started_at, finished_at FROM weave.workflow_runs
+WHERE organization_id = $1
+  AND id = $2`;
+async function getWorkflowRun(client, args) {
+    const result = await client.query({
+        text: exports.getWorkflowRunQuery,
+        values: [args.organizationId, args.workflowRunId],
+        rowMode: "array"
+    });
+    if (result.rows.length !== 1) {
+        return null;
+    }
+    const row = result.rows[0];
+    return {
+        id: row[0],
+        organizationId: row[1],
+        workflowTemplateId: row[2],
+        workflowVersionId: row[3],
+        status: row[4],
+        createdByUserId: row[5],
+        chatSessionId: row[6],
+        input: row[7],
+        output: row[8],
+        errorCode: row[9],
+        safeErrorMessage: row[10],
+        createdAt: row[11],
+        startedAt: row[12],
+        finishedAt: row[13]
+    };
+}
+exports.listWorkflowRunsQuery = `-- name: ListWorkflowRuns :many
+SELECT id, organization_id, workflow_template_id, workflow_version_id, status, created_by_user_id, chat_session_id, input, output, error_code, safe_error_message, created_at, started_at, finished_at FROM weave.workflow_runs
+WHERE organization_id = $1
+  AND (
+      $2::uuid IS NULL
+      OR workflow_template_id = $2::uuid
+  )
+  AND (
+      $3::text IS NULL
+      OR status = $3::text
+  )
+ORDER BY created_at DESC
+LIMIT $5 OFFSET $4`;
+async function listWorkflowRuns(client, args) {
+    const result = await client.query({
+        text: exports.listWorkflowRunsQuery,
+        values: [args.organizationId, args.workflowTemplateId, args.status, args.pageOffset, args.pageSize],
+        rowMode: "array"
+    });
+    return result.rows.map(row => {
+        return {
+            id: row[0],
+            organizationId: row[1],
+            workflowTemplateId: row[2],
+            workflowVersionId: row[3],
+            status: row[4],
+            createdByUserId: row[5],
+            chatSessionId: row[6],
+            input: row[7],
+            output: row[8],
+            errorCode: row[9],
+            safeErrorMessage: row[10],
+            createdAt: row[11],
+            startedAt: row[12],
+            finishedAt: row[13]
+        };
+    });
+}
+exports.updateWorkflowRunStatusQuery = `-- name: UpdateWorkflowRunStatus :one
+UPDATE weave.workflow_runs
+SET
+    status = $1,
+    output = $2,
+    error_code = $3,
+    safe_error_message = $4,
+    started_at = COALESCE(started_at, $5::timestamptz),
+    finished_at = $6::timestamptz
+WHERE organization_id = $7
+  AND id = $8
+RETURNING id, organization_id, workflow_template_id, workflow_version_id, status, created_by_user_id, chat_session_id, input, output, error_code, safe_error_message, created_at, started_at, finished_at`;
+async function updateWorkflowRunStatus(client, args) {
+    const result = await client.query({
+        text: exports.updateWorkflowRunStatusQuery,
+        values: [args.status, args.output, args.errorCode, args.safeErrorMessage, args.startedAt, args.finishedAt, args.organizationId, args.workflowRunId],
+        rowMode: "array"
+    });
+    if (result.rows.length !== 1) {
+        return null;
+    }
+    const row = result.rows[0];
+    return {
+        id: row[0],
+        organizationId: row[1],
+        workflowTemplateId: row[2],
+        workflowVersionId: row[3],
+        status: row[4],
+        createdByUserId: row[5],
+        chatSessionId: row[6],
+        input: row[7],
+        output: row[8],
+        errorCode: row[9],
+        safeErrorMessage: row[10],
+        createdAt: row[11],
+        startedAt: row[12],
+        finishedAt: row[13]
+    };
 }
-exports.upsertWorkflowStageStateQuery = `-- name: UpsertWorkflowStageState :one
-INSERT INTO weave_v1.workflow_stage_state (
-    workflow_id,
-    stage,
+exports.createWorkflowStepRunQuery = `-- name: CreateWorkflowStepRun :one
+INSERT INTO weave.workflow_step_runs (
+    id,
+    organization_id,
+    workflow_run_id,
+    step_key,
+    step_name,
+    step_kind,
     status,
-    blocked_reason,
-    updated_at
+    input
+) VALUES (
+    $1,
+    $2,
+    $3,
+    $4,
+    $5,
+    $6,
+    $7,
+    $8
 )
-SELECT w.id,
-       $1,
-       $2,
-       $3,
-       NOW()
-FROM weave_v1.workflow w
-WHERE w.id = $4
-  AND w.project_id = $5
-ON CONFLICT (workflow_id, stage) DO UPDATE
-SET status = EXCLUDED.status,
-    blocked_reason = EXCLUDED.blocked_reason,
-    updated_at = NOW()
-RETURNING workflow_id, stage, status, blocked_reason, updated_at`;
-async function upsertWorkflowStageState(client, args) {
+RETURNING id, organization_id, workflow_run_id, step_key, step_name, step_kind, status, agent_run_id, child_workflow_run_id, input, output, error_code, safe_error_message, created_at, started_at, finished_at`;
+async function createWorkflowStepRun(client, args) {
     const result = await client.query({
-        text: exports.upsertWorkflowStageStateQuery,
-        values: [args.stage, args.status, args.blockedReason, args.workflowId, args.projectId],
+        text: exports.createWorkflowStepRunQuery,
+        values: [args.id, args.organizationId, args.workflowRunId, args.stepKey, args.stepName, args.stepKind, args.status, args.input],
         rowMode: "array"
     });
     if (result.rows.length !== 1) {
@@ -241,24 +765,74 @@ async function upsertWorkflowStageState(client, args) {
     }
     const row = result.rows[0];
     return {
-        workflowId: row[0],
-        stage: row[1],
-        status: row[2],
-        blockedReason: row[3],
-        updatedAt: row[4]
+        id: row[0],
+        organizationId: row[1],
+        workflowRunId: row[2],
+        stepKey: row[3],
+        stepName: row[4],
+        stepKind: row[5],
+        status: row[6],
+        agentRunId: row[7],
+        childWorkflowRunId: row[8],
+        input: row[9],
+        output: row[10],
+        errorCode: row[11],
+        safeErrorMessage: row[12],
+        createdAt: row[13],
+        startedAt: row[14],
+        finishedAt: row[15]
     };
 }
-exports.getWorkflowStageStateQuery = `-- name: GetWorkflowStageState :one
-SELECT s.workflow_id, s.stage, s.status, s.blocked_reason, s.updated_at
-FROM weave_v1.workflow_stage_state s
-         INNER JOIN weave_v1.workflow w ON w.id = s.workflow_id
-WHERE s.workflow_id = $1
-  AND w.project_id = $2
-  AND s.stage = $3`;
-async function getWorkflowStageState(client, args) {
+exports.listWorkflowStepRunsQuery = `-- name: ListWorkflowStepRuns :many
+SELECT id, organization_id, workflow_run_id, step_key, step_name, step_kind, status, agent_run_id, child_workflow_run_id, input, output, error_code, safe_error_message, created_at, started_at, finished_at FROM weave.workflow_step_runs
+WHERE organization_id = $1
+  AND workflow_run_id = $2
+ORDER BY created_at, step_key`;
+async function listWorkflowStepRuns(client, args) {
+    const result = await client.query({
+        text: exports.listWorkflowStepRunsQuery,
+        values: [args.organizationId, args.workflowRunId],
+        rowMode: "array"
+    });
+    return result.rows.map(row => {
+        return {
+            id: row[0],
+            organizationId: row[1],
+            workflowRunId: row[2],
+            stepKey: row[3],
+            stepName: row[4],
+            stepKind: row[5],
+            status: row[6],
+            agentRunId: row[7],
+            childWorkflowRunId: row[8],
+            input: row[9],
+            output: row[10],
+            errorCode: row[11],
+            safeErrorMessage: row[12],
+            createdAt: row[13],
+            startedAt: row[14],
+            finishedAt: row[15]
+        };
+    });
+}
+exports.updateWorkflowStepRunStatusQuery = `-- name: UpdateWorkflowStepRunStatus :one
+UPDATE weave.workflow_step_runs
+SET
+    status = $1,
+    agent_run_id = $2::uuid,
+    child_workflow_run_id = $3::uuid,
+    output = $4,
+    error_code = $5,
+    safe_error_message = $6,
+    started_at = COALESCE(started_at, $7::timestamptz),
+    finished_at = $8::timestamptz
+WHERE organization_id = $9
+  AND id = $10
+RETURNING id, organization_id, workflow_run_id, step_key, step_name, step_kind, status, agent_run_id, child_workflow_run_id, input, output, error_code, safe_error_message, created_at, started_at, finished_at`;
+async function updateWorkflowStepRunStatus(client, args) {
     const result = await client.query({
-        text: exports.getWorkflowStageStateQuery,
-        values: [args.workflowId, args.projectId, args.stage],
+        text: exports.updateWorkflowStepRunStatusQuery,
+        values: [args.status, args.agentRunId, args.childWorkflowRunId, args.output, args.errorCode, args.safeErrorMessage, args.startedAt, args.finishedAt, args.organizationId, args.workflowStepRunId],
         rowMode: "array"
     });
     if (result.rows.length !== 1) {
@@ -266,33 +840,187 @@ async function getWorkflowStageState(client, args) {
     }
     const row = result.rows[0];
     return {
-        workflowId: row[0],
-        stage: row[1],
-        status: row[2],
-        blockedReason: row[3],
-        updatedAt: row[4]
+        id: row[0],
+        organizationId: row[1],
+        workflowRunId: row[2],
+        stepKey: row[3],
+        stepName: row[4],
+        stepKind: row[5],
+        status: row[6],
+        agentRunId: row[7],
+        childWorkflowRunId: row[8],
+        input: row[9],
+        output: row[10],
+        errorCode: row[11],
+        safeErrorMessage: row[12],
+        createdAt: row[13],
+        startedAt: row[14],
+        finishedAt: row[15]
     };
 }
-exports.listWorkflowStageStatesQuery = `-- name: ListWorkflowStageStates :many
-SELECT s.workflow_id, s.stage, s.status, s.blocked_reason, s.updated_at
-FROM weave_v1.workflow_stage_state s
-         INNER JOIN weave_v1.workflow w ON w.id = s.workflow_id
-WHERE s.workflow_id = $1
-  AND w.project_id = $2
-ORDER BY s.stage`;
-async function listWorkflowStageStates(client, args) {
+exports.insertWorkflowRunEventQuery = `-- name: InsertWorkflowRunEvent :one
+INSERT INTO weave.workflow_run_events (
+    id,
+    organization_id,
+    workflow_run_id,
+    workflow_step_run_id,
+    agent_run_id,
+    sequence,
+    kind,
+    message,
+    payload
+) VALUES (
+    $1,
+    $2,
+    $3,
+    $4::uuid,
+    $5::uuid,
+    $6,
+    $7,
+    $8,
+    $9
+)
+RETURNING id, organization_id, workflow_run_id, workflow_step_run_id, agent_run_id, sequence, kind, message, payload, created_at`;
+async function insertWorkflowRunEvent(client, args) {
     const result = await client.query({
-        text: exports.listWorkflowStageStatesQuery,
-        values: [args.workflowId, args.projectId],
+        text: exports.insertWorkflowRunEventQuery,
+        values: [args.id, args.organizationId, args.workflowRunId, args.workflowStepRunId, args.agentRunId, args.sequence, args.kind, args.message, args.payload],
+        rowMode: "array"
+    });
+    if (result.rows.length !== 1) {
+        return null;
+    }
+    const row = result.rows[0];
+    return {
+        id: row[0],
+        organizationId: row[1],
+        workflowRunId: row[2],
+        workflowStepRunId: row[3],
+        agentRunId: row[4],
+        sequence: row[5],
+        kind: row[6],
+        message: row[7],
+        payload: row[8],
+        createdAt: row[9]
+    };
+}
+exports.listWorkflowRunEventsQuery = `-- name: ListWorkflowRunEvents :many
+SELECT id, organization_id, workflow_run_id, workflow_step_run_id, agent_run_id, sequence, kind, message, payload, created_at FROM weave.workflow_run_events
+WHERE organization_id = $1
+  AND workflow_run_id = $2
+  AND sequence > $3
+ORDER BY sequence
+LIMIT $4`;
+async function listWorkflowRunEvents(client, args) {
+    const result = await client.query({
+        text: exports.listWorkflowRunEventsQuery,
+        values: [args.organizationId, args.workflowRunId, args.afterSequence, args.pageSize],
         rowMode: "array"
     });
     return result.rows.map(row => {
         return {
-            workflowId: row[0],
-            stage: row[1],
-            status: row[2],
-            blockedReason: row[3],
-            updatedAt: row[4]
+            id: row[0],
+            organizationId: row[1],
+            workflowRunId: row[2],
+            workflowStepRunId: row[3],
+            agentRunId: row[4],
+            sequence: row[5],
+            kind: row[6],
+            message: row[7],
+            payload: row[8],
+            createdAt: row[9]
+        };
+    });
+}
+exports.insertToolCallEventQuery = `-- name: InsertToolCallEvent :one
+INSERT INTO weave.tool_call_events (
+    id,
+    organization_id,
+    workflow_run_id,
+    workflow_step_run_id,
+    agent_run_id,
+    tool_call_id,
+    tool_name,
+    state,
+    arguments,
+    result,
+    error_code,
+    safe_error_message
+) VALUES (
+    $1,
+    $2,
+    $3::uuid,
+    $4::uuid,
+    $5::uuid,
+    $6,
+    $7,
+    $8,
+    $9,
+    $10,
+    $11,
+    $12
+)
+RETURNING id, organization_id, workflow_run_id, workflow_step_run_id, agent_run_id, tool_call_id, tool_name, state, arguments, result, error_code, safe_error_message, created_at`;
+async function insertToolCallEvent(client, args) {
+    const result = await client.query({
+        text: exports.insertToolCallEventQuery,
+        values: [args.id, args.organizationId, args.workflowRunId, args.workflowStepRunId, args.agentRunId, args.toolCallId, args.toolName, args.state, args.arguments, args.result, args.errorCode, args.safeErrorMessage],
+        rowMode: "array"
+    });
+    if (result.rows.length !== 1) {
+        return null;
+    }
+    const row = result.rows[0];
+    return {
+        id: row[0],
+        organizationId: row[1],
+        workflowRunId: row[2],
+        workflowStepRunId: row[3],
+        agentRunId: row[4],
+        toolCallId: row[5],
+        toolName: row[6],
+        state: row[7],
+        arguments: row[8],
+        result: row[9],
+        errorCode: row[10],
+        safeErrorMessage: row[11],
+        createdAt: row[12]
+    };
+}
+exports.listToolCallEventsQuery = `-- name: ListToolCallEvents :many
+SELECT id, organization_id, workflow_run_id, workflow_step_run_id, agent_run_id, tool_call_id, tool_name, state, arguments, result, error_code, safe_error_message, created_at FROM weave.tool_call_events
+WHERE organization_id = $1
+  AND (
+      $2::uuid IS NULL
+      OR workflow_run_id = $2::uuid
+  )
+  AND (
+      $3::uuid IS NULL
+      OR agent_run_id = $3::uuid
+  )
+ORDER BY created_at
+LIMIT $5 OFFSET $4`;
+async function listToolCallEvents(client, args) {
+    const result = await client.query({
+        text: exports.listToolCallEventsQuery,
+        values: [args.organizationId, args.workflowRunId, args.agentRunId, args.pageOffset, args.pageSize],
+        rowMode: "array"
+    });
+    return result.rows.map(row => {
+        return {
+            id: row[0],
+            organizationId: row[1],
+            workflowRunId: row[2],
+            workflowStepRunId: row[3],
+            agentRunId: row[4],
+            toolCallId: row[5],
+            toolName: row[6],
+            state: row[7],
+            arguments: row[8],
+            result: row[9],
+            errorCode: row[10],
+            safeErrorMessage: row[11],
+            createdAt: row[12]
         };
     });
 }