@inflexa-ai/harness 0.35.8 → 0.36.1

package/dist/workflows/target-assessment/lib/regulatory-actions.js

@@ -1,176 +0,0 @@
-/**
- * Per-drug regulatory-action collector. Queries openFDA Structured Product
- * Labels (boxed warning, Section 5 warnings_and_cautions, REMS indicator)
- * and the EMA referrals catalogue (Article 31 / Article 20 procedures)
- * for each drug, then maps both into the dossier's RegulatoryActionRow
- * shape.
- *
- * Coverage that legitimately has no
- * machine-readable source (e.g., EMA assessment-report procedure codes like
- * EMEA/H/A-31/1291) is omitted rather than backfilled with curation — the
- * source_url points at the canonical document where the human reader can
- * extract the additional context.
- */
-import { withHost } from "../../../lib/host-concurrency.js";
-import { getReferralsByDrug } from "../../../tools/lib/ema-client.js";
-import { getDrugLabelActions } from "../../../tools/lib/openfda-client.js";
-import { segmentLabelSafety } from "./fda-label-safety.js";
-function formatEffectiveTime(yyyymmdd) {
-    if (!yyyymmdd || yyyymmdd.length < 6)
-        return "";
-    return `${yyyymmdd.slice(0, 4)}-${yyyymmdd.slice(4, 6)}`;
-}
-function formatEmaDate(ddmmyyyy) {
-    if (!ddmmyyyy)
-        return "";
-    const parts = ddmmyyyy.split("/");
-    if (parts.length !== 3)
-        return "";
-    return `${parts[2]}-${parts[1]}`;
-}
-const FINDING_CHAR_LIMIT = 2000;
-function clipFinding(text) {
-    const cleaned = text.replace(/\s+/g, " ").trim();
-    if (cleaned.length <= FINDING_CHAR_LIMIT)
-        return cleaned;
-    return `${cleaned.slice(0, FINDING_CHAR_LIMIT - 1).trimEnd()}…`;
-}
-/**
- * Project a fetched label onto the shared typed safety form. Returns null when
- * the label carries no application number: its warnings could not then be cited
- * back to a document, and an uncitable warning is not evidence.
- */
-function labelSafetyOf(drug, label) {
-    if (!label.applicationNumber)
-        return null;
-    const sections = [];
-    if (label.boxedWarning)
-        sections.push({ section: "boxed_warning", text: label.boxedWarning });
-    if (label.warningsAndCautions)
-        sections.push({ section: "warnings_and_precautions", text: label.warningsAndCautions });
-    if (sections.length === 0)
-        return null;
-    return {
-        application_number: label.applicationNumber,
-        drug_name: label.genericName ?? label.brandName ?? drug.name,
-        effective_time: label.effectiveTime ?? undefined,
-        source_url: label.sourceUrl || undefined,
-        sections,
-    };
-}
-function fdaRowsFor(drug, labels) {
-    if (labels.length === 0)
-        return [];
-    const sorted = [...labels].sort((a, b) => (b.effectiveTime ?? "").localeCompare(a.effectiveTime ?? ""));
-    const latest = sorted[0];
-    const rows = [];
-    const actionDate = formatEffectiveTime(latest.effectiveTime);
-    // The label's own prose, segmented once and attributed to organs, is what
-    // lets each row cite the section a reader can open rather than only the
-    // agency and the date.
-    const labelSafety = labelSafetyOf(drug, latest);
-    const signals = labelSafety ? segmentLabelSafety([labelSafety]).signals : [];
-    const evidenceFrom = (section) => signals.filter((s) => s.source_section === section).map((s) => s.evidence);
-    if (latest.boxedWarning) {
-        rows.push({
-            drug_chembl_id: drug.chemblId,
-            drug_name: drug.name,
-            agency: "FDA",
-            action_kind: "black_box",
-            source_kind: "boxed_warning",
-            action_date: actionDate,
-            source_date: actionDate,
-            application_number: latest.applicationNumber ?? undefined,
-            finding: clipFinding(latest.boxedWarning),
-            source_url: latest.sourceUrl || undefined,
-            evidence: evidenceFrom("boxed_warning"),
-        });
-    }
-    if (latest.warningsAndCautions) {
-        rows.push({
-            drug_chembl_id: drug.chemblId,
-            drug_name: drug.name,
-            agency: "FDA",
-            action_kind: "label_warning",
-            source_kind: "label_warning",
-            action_date: actionDate,
-            source_date: actionDate,
-            application_number: latest.applicationNumber ?? undefined,
-            label_section: "5",
-            finding: clipFinding(latest.warningsAndCautions),
-            source_url: latest.sourceUrl || undefined,
-            evidence: evidenceFrom("warnings_and_precautions"),
-        });
-    }
-    if (latest.hasRems) {
-        rows.push({
-            drug_chembl_id: drug.chemblId,
-            drug_name: drug.name,
-            agency: "FDA",
-            action_kind: "REMS",
-            source_kind: "rems",
-            action_date: actionDate,
-            source_date: actionDate,
-            application_number: latest.applicationNumber ?? undefined,
-            finding: `Risk Evaluation and Mitigation Strategy referenced in current label (${latest.brandName ?? latest.genericName ?? drug.name}).`,
-            source_url: latest.sourceUrl || undefined,
-            evidence: [],
-        });
-    }
-    return rows;
-}
-function classifyEmaActionKind(referral) {
-    const status = referral.currentStatus.toLowerCase();
-    if (status.includes("withdraw"))
-        return "withdrawal";
-    return "referral";
-}
-function emaRowsFor(drug, referrals) {
-    return referrals.map((r) => {
-        const date = formatEmaDate(r.europeanCommissionDecisionDate) ||
-            formatEmaDate(r.chmpOpinionDate) ||
-            formatEmaDate(r.cmdhPositionDate) ||
-            formatEmaDate(r.pracRecommendationDate) ||
-            formatEmaDate(r.procedureStartDate);
-        const findingParts = [];
-        if (r.referralType)
-            findingParts.push(r.referralType);
-        if (r.referenceNumber)
-            findingParts.push(`(${r.referenceNumber})`);
-        if (r.currentStatus)
-            findingParts.push(`— ${r.currentStatus}`);
-        if (r.referralName && r.referralName.toLowerCase() !== drug.name.toLowerCase()) {
-            findingParts.push(`re: ${r.referralName}`);
-        }
-        return {
-            drug_chembl_id: drug.chemblId,
-            drug_name: drug.name,
-            agency: "EMA",
-            action_kind: classifyEmaActionKind(r),
-            source_kind: classifyEmaActionKind(r) === "withdrawal" ? "withdrawal" : "referral",
-            action_date: date,
-            source_date: date,
-            finding: clipFinding(findingParts.join(" ")),
-            source_url: r.referralUrl || undefined,
-            evidence: [],
-        };
-    });
-}
-/**
- * Fetch regulatory actions (FDA label + EMA referrals) for a set of drugs.
- * Per-drug failures are isolated — one drug throwing does not blank out
- * the rest. Returns an empty array when no drugs are provided or no source
- * returned any actions.
- */
-export async function fetchRegulatoryActions(drugs) {
-    if (drugs.length === 0)
-        return [];
-    const perDrug = await Promise.all(drugs.map(async (drug) => {
-        const [fdaLabels, emaReferrals] = await Promise.all([
-            withHost("openfda", () => getDrugLabelActions(drug.name)).catch(() => []),
-            withHost("ema", () => getReferralsByDrug(drug.name)).catch(() => []),
-        ]);
-        return [...fdaRowsFor(drug, fdaLabels), ...emaRowsFor(drug, emaReferrals)];
-    }));
-    return perDrug.flat();
-}

package/dist/workflows/target-assessment/lib/safety-corroboration.d.ts

@@ -1,44 +0,0 @@
-/**
- * The safety-evidence corroboration spine.
- *
- * A run queries a dozen-plus independent sources and files each one's output in
- * its own dossier section. This fold asks the question none of those sections
- * can: for a given organ, do the sources agree? Agreement across independent
- * sources is itself evidence, and it is what separates a real organ liability
- * from a single-source artefact.
- *
- * The fold re-fetches nothing. Every signal it reads is already in hand when it
- * runs, and a source that also populates a section of its own is referenced
- * here as a contribution rather than restated — there is one evidence path, not
- * two.
- *
- * **The source list is open.** A source is one entry in `SIGNAL_SOURCES`
- * declaring its id and how to read its signals out of the run's inputs.
- * Everything downstream — grouping, counting, thresholding, evidence assembly —
- * is written against the id-bearing record, so a fifteenth collector joins the
- * spine by adding an entry and changes neither the fold nor the schema.
- */
-import type { SafetyCorroboration } from "@inflexa-ai/harness/contracts/target-dossier.js";
-import type { Phase1Bundle } from "../schemas.js";
-import type { OrganSignalProjection } from "./fda-label-safety.js";
-/** Distinct sources an organ needs before the spine calls it corroborated. */
-export declare const MIN_INDEPENDENT_SOURCES = 2;
-/** What the section reports as having emptied it. */
-export declare const CORROBORATION_FILTER: string;
-/** Everything the fold reads. Already collected — nothing here is fetched. */
-export interface CorroborationInput {
-    readonly phase1: Phase1Bundle;
-    /** Per-organ FDA label warnings segmented at the approval-precedent step. */
-    readonly regulatoryOrganSignals: OrganSignalProjection | null;
-}
-/**
- * Fold the run's per-organ safety signals into one corroboration record per
- * organ.
- *
- * `dropped_count` counts signals — the fold's input unit — discarded because
- * their organ did not resolve, because their source produced no locator, or
- * because their organ drew fewer than `MIN_INDEPENDENT_SOURCES` distinct
- * sources. A fold that ends with no record reports `filtered` with that count
- * rather than an empty `available`.
- */
-export declare function assembleSafetyCorroboration(input: CorroborationInput): SafetyCorroboration;

package/dist/workflows/target-assessment/lib/safety-corroboration.js

@@ -1,273 +0,0 @@
-/**
- * The safety-evidence corroboration spine.
- *
- * A run queries a dozen-plus independent sources and files each one's output in
- * its own dossier section. This fold asks the question none of those sections
- * can: for a given organ, do the sources agree? Agreement across independent
- * sources is itself evidence, and it is what separates a real organ liability
- * from a single-source artefact.
- *
- * The fold re-fetches nothing. Every signal it reads is already in hand when it
- * runs, and a source that also populates a section of its own is referenced
- * here as a contribution rather than restated — there is one evidence path, not
- * two.
- *
- * **The source list is open.** A source is one entry in `SIGNAL_SOURCES`
- * declaring its id and how to read its signals out of the run's inputs.
- * Everything downstream — grouping, counting, thresholding, evidence assembly —
- * is written against the id-bearing record, so a fifteenth collector joins the
- * spine by adding an entry and changes neither the fold nor the schema.
- */
-import { isSafetyRelevant, meetsTpmFloor, resolveTissueOrganSystem } from "../assemblers/safety.js";
-import { resolveHpoOrgan } from "./hpo-organ-map.js";
-import { resolveImpcOrgan } from "./impc-organ-map.js";
-import { classifyOrgan } from "./meddra-organ-map.js";
-/** Distinct sources an organ needs before the spine calls it corroborated. */
-export const MIN_INDEPENDENT_SOURCES = 2;
-/** What the section reports as having emptied it. */
-export const CORROBORATION_FILTER = `organ signals with no resolvable organ or locator, or whose organ drew fewer than ` + `${MIN_INDEPENDENT_SOURCES} independent sources`;
-/**
- * Curated human phenotypes ranked per organ. A well-annotated gene carries
- * hundreds of HPO terms under one organ system; beyond the ranked head they
- * restate the same organ-level signal, so the source raises it once at the
- * granularity a reader can act on.
- */
-const PHENOTYPES_PER_ORGAN = 3;
-// ── Source extractors ────────────────────────────────────────────────
-/** Warning fragments from FDA prescribing information, already organ-keyed. */
-function extractRegulatoryLabels(input) {
-    const projection = input.regulatoryOrganSignals;
-    if (!projection)
-        return [];
-    return projection.signals.map((s) => ({
-        organ: s.organ,
-        signal: `${s.drug_name} label §${s.label_section}: ${s.excerpt}`,
-        evidence: s.evidence.regulatory_reference ? s.evidence : null,
-    }));
-}
-/** Mouse knockout phenotype systems, keyed by the MGI accession for the gene. */
-function extractKnockoutPhenotypes(input) {
-    const impc = input.phase1.collectors.impc;
-    if (impc.coverage !== "available")
-        return [];
-    const accession = impc.data.mgiAccessionId;
-    return impc.data.organSystems.map((bucket) => ({
-        organ: resolveImpcOrgan(bucket),
-        signal: `mouse knockout phenotype in the ${bucket} system`,
-        evidence: accession
-            ? {
-                source: "impc",
-                accession,
-                predicate: "knockout_phenotype",
-                excerpt: `${impc.data.mouseMarkerSymbol ?? ""} knockout phenotypes in the ${bucket} system`.trim(),
-                metadata: { bucket, phenotype_count: impc.data.phenotypeCount },
-            }
-            : null,
-    }));
-}
-/** Curated human phenotypes, resolved by HPO ancestry rather than by label. */
-function extractHumanPhenotypes(input) {
-    const monarch = input.phase1.collectors.monarch;
-    if (monarch.coverage !== "available")
-        return [];
-    const ranked = [...monarch.data.phenotypes].sort((a, b) => b.publications.length - a.publications.length || (b.frequencyPercent ?? 0) - (a.frequencyPercent ?? 0) || a.label.localeCompare(b.label));
-    const perOrgan = new Map();
-    const out = [];
-    for (const p of ranked) {
-        const organ = resolveHpoOrgan(p.hpoId, p.ancestorIds);
-        if (organ === null) {
-            out.push({ organ: null, signal: p.label, evidence: null });
-            continue;
-        }
-        const seen = perOrgan.get(organ) ?? 0;
-        if (seen >= PHENOTYPES_PER_ORGAN)
-            continue;
-        perOrgan.set(organ, seen + 1);
-        const pmid = p.publications.find((pub) => pub.startsWith("PMID:"))?.slice("PMID:".length);
-        out.push({
-            organ,
-            signal: `curated human phenotype: ${p.label}`,
-            evidence: {
-                source: "monarch",
-                accession: p.hpoId,
-                ...(pmid ? { pmid } : {}),
-                predicate: "human_phenotype",
-                is_human: true,
-                excerpt: p.label,
-                metadata: {
-                    ...(p.diseaseContext ? { disease_context: p.diseaseContext } : {}),
-                    ...(p.frequencyPercent != null ? { frequency_percent: p.frequencyPercent } : {}),
-                    ...(p.primaryKnowledgeSource ? { knowledge_source: p.primaryKnowledgeSource } : {}),
-                },
-            },
-        });
-    }
-    return out;
-}
-/** Open Targets' curated safety liabilities, keyed by the Ensembl accession. */
-function extractCuratedSafetyLiabilities(input) {
-    const ot = input.phase1.collectors.opentargets;
-    if (ot.coverage !== "available")
-        return [];
-    return ot.data.safetyLiabilities.map((liability) => ({
-        organ: classifyOrgan(liability.event) ?? classifyOrgan(liability.biosamples.join(" ")),
-        signal: `curated safety liability: ${liability.event}`,
-        evidence: {
-            source: "opentargets:safety",
-            accession: ot.data.ensemblId,
-            predicate: "known_safety_liability",
-            excerpt: liability.effects ? `${liability.event} — ${liability.effects}` : liability.event,
-            metadata: { biosamples: liability.biosamples, curator: liability.source },
-        },
-    }));
-}
-/**
- * Baseline expression in safety-relevant tissues.
- *
- * The atlas reaches the dossier through the Open Targets `baselineExpression`
- * surface, narrowed to the GTEx bulk-tissue rows — the same path
- * `reference_biology.normal_tissue_expression` and the off-tissue risk rows
- * read, with the same safety-relevance and floor rules applied. Only the
- * highest-expressing tissue per organ is raised: several tissues mapping to one
- * organ are one expression signal about that organ.
- */
-function extractExpressionAtlas(input) {
-    const expression = input.phase1.collectors.expressionHuman;
-    if (expression.coverage !== "available")
-        return [];
-    const accession = input.phase1.resolved.ids.ensembl;
-    const best = new Map();
-    const unresolved = [];
-    for (const t of expression.data.tissues) {
-        const value = t.value ?? 0;
-        if (!isSafetyRelevant(t.tissueLabel, t.organSystem) || !meetsTpmFloor(t.tissueLabel, value))
-            continue;
-        const organ = resolveTissueOrganSystem(t.tissueLabel, t.organSystem);
-        if (organ === null) {
-            unresolved.push({ organ: null, signal: `${t.tissueLabel} expression`, evidence: null });
-            continue;
-        }
-        const current = best.get(organ);
-        if (!current || value > current.value)
-            best.set(organ, { tissue: t.tissueLabel, value });
-    }
-    const resolved = [...best.entries()].map(([organ, hit]) => {
-        const signal = `${expression.data.unit} expression ${hit.value} in ${hit.tissue}`;
-        return {
-            organ,
-            signal,
-            evidence: accession
-                ? {
-                    source: `expression:${expression.data.source}`,
-                    accession,
-                    predicate: "expressed_in_safety_tissue",
-                    score: hit.value,
-                    excerpt: `${hit.tissue}: ${hit.value} (${expression.data.unit})`,
-                    metadata: {
-                        tissue: hit.tissue,
-                        unit: expression.data.unit,
-                        normalization_notes: expression.data.normalization_notes,
-                    },
-                }
-                : null,
-        };
-    });
-    return [...resolved, ...unresolved];
-}
-/**
- * The registered sources.
- *
- * This array is the whole integration surface: an id, and how to read that
- * source's organ-bearing signals out of what the run already collected.
- */
-const SIGNAL_SOURCES = [
-    { id: "fda_label", extract: extractRegulatoryLabels },
-    { id: "impc", extract: extractKnockoutPhenotypes },
-    { id: "monarch", extract: extractHumanPhenotypes },
-    { id: "opentargets_safety", extract: extractCuratedSafetyLiabilities },
-    { id: "expression_atlas", extract: extractExpressionAtlas },
-];
-/**
- * Fold the run's per-organ safety signals into one corroboration record per
- * organ.
- *
- * `dropped_count` counts signals — the fold's input unit — discarded because
- * their organ did not resolve, because their source produced no locator, or
- * because their organ drew fewer than `MIN_INDEPENDENT_SOURCES` distinct
- * sources. A fold that ends with no record reports `filtered` with that count
- * rather than an empty `available`.
- */
-export function assembleSafetyCorroboration(input) {
-    const sourcesConsidered = [];
-    const admitted = [];
-    let dropped = 0;
-    for (const source of SIGNAL_SOURCES) {
-        const signals = source.extract(input);
-        if (signals.length === 0)
-            continue;
-        sourcesConsidered.push(source.id);
-        const seen = new Set();
-        for (const raw of signals) {
-            if (raw.organ === null || raw.evidence === null) {
-                dropped += 1;
-                continue;
-            }
-            const key = `${raw.organ}\u0000${raw.signal}`;
-            if (seen.has(key))
-                continue;
-            seen.add(key);
-            admitted.push({
-                source: source.id,
-                organ: raw.organ,
-                contribution: { source: source.id, signal: raw.signal, evidence: raw.evidence },
-            });
-        }
-    }
-    if (sourcesConsidered.length === 0) {
-        return {
-            coverage: "queried_no_data",
-            error: { message: "no source produced an organ-bearing safety signal" },
-        };
-    }
-    const byOrgan = new Map();
-    for (const item of admitted) {
-        const bucket = byOrgan.get(item.organ);
-        if (bucket)
-            bucket.push(item);
-        else
-            byOrgan.set(item.organ, [item]);
-    }
-    const rows = [];
-    for (const [organ, items] of byOrgan) {
-        const corroborating = [...new Set(items.map((i) => i.source))].sort();
-        if (corroborating.length < MIN_INDEPENDENT_SOURCES) {
-            dropped += items.length;
-            continue;
-        }
-        const contributions = items.map((i) => i.contribution);
-        rows.push({
-            organ,
-            contributions,
-            corroborating_sources: corroborating,
-            independent_source_count: corroborating.length,
-            support: { state: "scored", evidence: contributions.map((c) => c.evidence) },
-        });
-    }
-    rows.sort((a, b) => b.independent_source_count - a.independent_source_count || a.organ.localeCompare(b.organ));
-    // Reaching here means at least one source emitted a signal — that is what put
-    // it in `sourcesConsidered` — and every emitted signal was either admitted or
-    // counted as dropped. So no record left standing means the fold's own
-    // thresholds took them all, and `dropped` is necessarily positive.
-    if (rows.length === 0) {
-        return { coverage: "filtered", filter: CORROBORATION_FILTER, dropped_count: dropped };
-    }
-    return {
-        coverage: "available",
-        data: {
-            rows,
-            sources_considered: [...sourcesConsidered].sort(),
-            min_independent_sources: MIN_INDEPENDENT_SOURCES,
-        },
-        ...(dropped > 0 ? { dropped_count: dropped } : {}),
-    };
-}

package/dist/workflows/target-assessment/lib/structured-llm.d.ts

@@ -1,61 +0,0 @@
-/**
- * Structured-output LLM helper for the target-assessment DBOS workflow.
- *
- * Uses a tool-choice forcing pattern: a single Anthropic tool named `submit`
- * carries the Zod schema as its `input_schema`, and
- * `tool_choice: { type: "tool", name: "submit" }` forces the model to fill
- * it. The tool's `input` IS the structured output.
- *
- * This intentionally does NOT pull in the harness `runAgent` loop — Phase-2
- * decisions are zero-tool single-shot calls. Phase-5 syntheses today use
- * regulatory-guidance + approval-precedent retrieval tools; the harness
- * port drops those grounding tools (PR #4 ships single-shot synthesis; a
- * follow-up may reintroduce the retrieval tools through the agent loop).
- *
- * Calls are routed through `runLlmStep`, so each LLM call lives in its own
- * `DBOS.runStep({name})` cache slot and a billing-gateway 402 self-cancels the
- * workflow rather than returning a coverage envelope.
- */
-import { z } from "zod";
-import type { AgentSession } from "../../../auth/types.js";
-import type { Logger } from "../../../lib/logger.js";
-import type { AgentChat } from "../../../providers/types.js";
-import { BUDGET_EXCEEDED_SENTINEL } from "./llm-step.js";
-export interface StructuredLlmCallOptions<TSchema extends z.ZodType> {
-    /** Operational logging seam, forwarded to `runLlmStep`; omitted falls back to no-op. */
-    readonly logger?: Logger;
-    /** Attempt-numbered durable-step name (e.g. `"ta-decision:modulator-triage:0"`). */
-    readonly stepName: string;
-    /** Agent id stamped on telemetry and billing-gateway provenance. */
-    readonly agentId: string;
-    readonly provider: AgentChat;
-    readonly session: AgentSession;
-    readonly system: string;
-    readonly prompt: string;
-    readonly schema: TSchema;
-    readonly model: string;
-    readonly signal?: AbortSignal;
-}
-export type StructuredLlmResult<TSchema extends z.ZodType> = {
-    readonly kind: "ok";
-    readonly value: z.infer<TSchema>;
-} | {
-    readonly kind: "budget-exceeded";
-    readonly sentinel: typeof BUDGET_EXCEEDED_SENTINEL;
-};
-/**
- * Thrown when the model returned a structured-output payload that does
- * not parse against the declared Zod schema. The caller decides whether
- * to wrap as `coverage: "queried_no_data"` or rethrow as a hard failure.
- */
-export declare class StructuredOutputParseError extends Error {
-    readonly cause?: unknown | undefined;
-    constructor(message: string, cause?: unknown | undefined);
-}
-/**
- * Run one structured-output LLM call. Forces the model to call the
- * `submit` tool whose input schema is `opts.schema`; parses the tool
- * input via `safeParse` and returns the typed value. A billing-gateway 402 returns
- * the budget-exceeded sentinel; non-402 throws + parse errors throw.
- */
-export declare function structuredLlmCall<TSchema extends z.ZodType>(opts: StructuredLlmCallOptions<TSchema>): Promise<StructuredLlmResult<TSchema>>;

package/dist/workflows/target-assessment/lib/structured-llm.js

@@ -1,102 +0,0 @@
-/**
- * Structured-output LLM helper for the target-assessment DBOS workflow.
- *
- * Uses a tool-choice forcing pattern: a single Anthropic tool named `submit`
- * carries the Zod schema as its `input_schema`, and
- * `tool_choice: { type: "tool", name: "submit" }` forces the model to fill
- * it. The tool's `input` IS the structured output.
- *
- * This intentionally does NOT pull in the harness `runAgent` loop — Phase-2
- * decisions are zero-tool single-shot calls. Phase-5 syntheses today use
- * regulatory-guidance + approval-precedent retrieval tools; the harness
- * port drops those grounding tools (PR #4 ships single-shot synthesis; a
- * follow-up may reintroduce the retrieval tools through the agent loop).
- *
- * Calls are routed through `runLlmStep`, so each LLM call lives in its own
- * `DBOS.runStep({name})` cache slot and a billing-gateway 402 self-cancels the
- * workflow rather than returning a coverage envelope.
- */
-import { jsonSchema, tool as aiTool } from "ai";
-import { z } from "zod";
-import { runLlmStep } from "./llm-step.js";
-const SUBMIT_TOOL_NAME = "submit";
-/**
- * Thrown when the model returned a structured-output payload that does
- * not parse against the declared Zod schema. The caller decides whether
- * to wrap as `coverage: "queried_no_data"` or rethrow as a hard failure.
- */
-export class StructuredOutputParseError extends Error {
-    cause;
-    constructor(message, cause) {
-        super(message);
-        this.cause = cause;
-        this.name = "StructuredOutputParseError";
-    }
-}
-/**
- * Convert a Zod schema to the JSON Schema shape Anthropic accepts as
- * `tool.input_schema`. Strips `$schema` (Anthropic rejects it) and asserts
- * a top-level `"type": "object"` (Anthropic rejects oneOf at the root).
- */
-function schemaToJsonSchema(schema, stepName) {
-    const jsonSchema = z.toJSONSchema(schema);
-    delete jsonSchema.$schema;
-    if (jsonSchema.type !== "object") {
-        throw new Error(`structuredLlmCall(${stepName}): schema must emit top-level "type":"object", ` + `got ${JSON.stringify(jsonSchema.type)}`);
-    }
-    // `z.toJSONSchema()` returns an untyped JSON-schema object; it is structurally
-    // Anthropic's `input_schema` once the top-level `type:"object"` check above passes
-    // (the one shape Anthropic requires), which is the invariant making this cast safe.
-    return jsonSchema;
-}
-function extractToolUseInput(blocks) {
-    for (const block of blocks) {
-        const part = block;
-        if (part.type === "tool-call" && part.toolName === SUBMIT_TOOL_NAME) {
-            return part.input;
-        }
-    }
-    return undefined;
-}
-/**
- * Run one structured-output LLM call. Forces the model to call the
- * `submit` tool whose input schema is `opts.schema`; parses the tool
- * input via `safeParse` and returns the typed value. A billing-gateway 402 returns
- * the budget-exceeded sentinel; non-402 throws + parse errors throw.
- */
-export async function structuredLlmCall(opts) {
-    const inputSchema = schemaToJsonSchema(opts.schema, opts.stepName);
-    const req = {
-        system: opts.system,
-        messages: [{ role: "user", content: opts.prompt }],
-        tools: {
-            [SUBMIT_TOOL_NAME]: aiTool({
-                description: `Submit the structured output. Call this tool exactly once with the final answer.`,
-                inputSchema: jsonSchema(inputSchema),
-            }),
-        },
-        toolChoice: { type: "tool", toolName: SUBMIT_TOOL_NAME },
-    };
-    const result = await runLlmStep({
-        ...(opts.logger ? { logger: opts.logger } : {}),
-        stepName: opts.stepName,
-        agentId: opts.agentId,
-        provider: opts.provider,
-        req,
-        session: opts.session,
-        signal: opts.signal,
-    });
-    if (result.kind === "budget-exceeded") {
-        return result;
-    }
-    const content = result.response.message.content;
-    const raw = extractToolUseInput(Array.isArray(content) ? content : []);
-    if (raw === undefined) {
-        throw new StructuredOutputParseError(`structuredLlmCall(${opts.stepName}): model returned no submit tool_use block`);
-    }
-    const parsed = opts.schema.safeParse(raw);
-    if (!parsed.success) {
-        throw new StructuredOutputParseError(`structuredLlmCall(${opts.stepName}): submit payload failed schema validation: ${parsed.error.message}`, parsed.error);
-    }
-    return { kind: "ok", value: parsed.data };
-}