@inflexa-ai/harness 0.46.0 → 0.47.0

package/dist/tasks/extract-values-script.js

@@ -1,180 +0,0 @@
-/**
- * The fixed extraction script and its wire protocol.
- *
- * The extraction arm runs this one Python script in the sandbox. The script reads one JSON input: a list
- * of path, format, and hash triples. For each triple the script hashes the file bytes with a streamed
- * sha256 before any read. If the on-disk hash does not match the pinned hash, the script refuses the file
- * as a typed error. If the hash matches, the script reads the file from the read-only analysis mount, and
- * it parses the file by the carried format. A parquet file uses pyarrow. The script emits one JSON map:
- * each path to its rows, or to a typed error. The script decides nothing else. It applies no filter and no
- * projection.
- *
- * The host decides the format one time, and the request carries it. Thus the script derives no reader from
- * an extension, and it refuses a request that names no format. The JSON arm obeys the strict host shape, an
- * array of flat objects, thus a shape that the host refuses is a refusal here too and it never comes back
- * as a table that pandas inferred.
- *
- * The harness holds the script as a string constant, thus the package ships no separate asset file. The
- * script reaches the container as the argument of `python3 -c`. The input reaches the container as one
- * environment variable.
- */
-import { z } from "zod";
-/**
- * The environment variable that carries the script input. The workflow body sets it to the JSON list of
- * path, format, and hash triples. The script reads it back one time.
- */
-export const EXTRACTION_INPUT_ENV = "CORTEX_EXTRACTION_REQUESTS";
-/**
- * One artifact row, as plain cells. A text-backed format holds a numeric column as a string, thus a cell
- * is a string or a number.
- */
-const ExtractionRowSchema = z.record(z.string(), z.union([z.string(), z.number()]));
-/**
- * The outcome for one path. A clean read gives the rows. A per-file read fault gives a typed error, and
- * the script still emits the map. The arm keeps the rows and drops the error, thus a failed path reads as
- * an unread artifact downstream.
- */
-const ExtractOutcomeSchema = z.union([
-    z.object({ rows: z.array(ExtractionRowSchema) }),
-    z.object({ error: z.object({ type: z.string(), message: z.string() }) }),
-]);
-/** The script output: each requested path to its outcome. */
-export const ExtractValuesResultSchema = z.record(z.string(), ExtractOutcomeSchema);
-/**
- * The one extraction script. The workflow body runs it as the argument of `python3 -c`. The script reads
- * the request list from `CORTEX_EXTRACTION_REQUESTS`, and it emits the value map to stdout.
- *
- * The Python comments obey the same Simplified Technical English rule as the harness comments.
- */
-export const EXTRACTION_SCRIPT = `import hashlib
-import json
-import math
-import os
-import sys
-
-import pandas as pd
-
-
-def sha256_of(path):
-    # The host pins the exact bytes with a streamed sha256, in the "sha256:<hex>" form. Mirror that form
-    # here, and stream the file in blocks, thus a large file never loads fully into memory.
-    digest = hashlib.sha256()
-    with open(path, "rb") as handle:
-        for block in iter(lambda: handle.read(1024 * 1024), b""):
-            digest.update(block)
-    return "sha256:" + digest.hexdigest()
-
-
-def coerce_cell(value):
-    # A null cell becomes None, thus the record drops the key.
-    if value is None:
-        return None
-    # A numpy scalar becomes a plain Python scalar.
-    if hasattr(value, "item"):
-        try:
-            value = value.item()
-        except (ValueError, TypeError):
-            return str(value)
-    if isinstance(value, bool):
-        return "true" if value else "false"
-    if isinstance(value, float):
-        if math.isnan(value) or math.isinf(value):
-            return None
-        return value
-    if isinstance(value, int):
-        return value
-    if isinstance(value, str):
-        return value
-    return str(value)
-
-
-def read_frame(path, fmt):
-    # pyarrow reads the parquet columnar format.
-    if fmt == "parquet":
-        return pd.read_parquet(path, engine="pyarrow")
-    if fmt == "tsv":
-        # keep_default_na=False keeps a literal cell such as "NA" or an empty string as its text, and the
-        # host parser keeps it too. A default read turns each into NaN, and the row builder drops the key.
-        return pd.read_csv(path, sep="\\t", dtype=str, keep_default_na=False)
-    if fmt == "csv":
-        # keep_default_na=False keeps a literal cell such as "NA" or an empty string as its text, thus a
-        # text cell survives and the row keeps the key.
-        return pd.read_csv(path, dtype=str, keep_default_na=False)
-    # The host decides the format for both arms. A request with no decided format is a protocol fault, thus
-    # the file refuses here and no reader guesses at it.
-    raise ValueError("the request names no supported format: " + str(fmt))
-
-
-def json_rows(path):
-    # The host reads a JSON table as an array of flat objects, and it refuses any other shape. Obey the
-    # same shape here. An inference pass would turn a shape that the host refuses into a different table.
-    with open(path, "rb") as handle:
-        value = json.load(handle)
-    if not isinstance(value, list):
-        raise ValueError("the JSON top-level value is not an array")
-    rows = []
-    for item in value:
-        if not isinstance(item, dict):
-            raise ValueError("a JSON array item is not an object")
-        row = {}
-        for key, cell in item.items():
-            if isinstance(cell, (dict, list)):
-                raise ValueError("a JSON cell holds a nested value")
-            coerced = coerce_cell(cell)
-            if coerced is not None:
-                row[str(key)] = coerced
-        rows.append(row)
-    return rows
-
-
-def rows_of(frame):
-    # A null cell becomes None before the record build, thus a missing cell drops.
-    clean = frame.astype(object).where(pd.notnull(frame), None)
-    records = clean.to_dict(orient="records")
-    rows = []
-    for record in records:
-        row = {}
-        for key, value in record.items():
-            cell = coerce_cell(value)
-            if cell is not None:
-                row[str(key)] = cell
-        rows.append(row)
-    return rows
-
-
-def rows_for(path, fmt):
-    # The JSON arm reads the strict host shape itself. Each other format reads through pandas.
-    if fmt == "json":
-        return json_rows(path)
-    return rows_of(read_frame(path, fmt))
-
-
-def main():
-    raw = os.environ.get("${EXTRACTION_INPUT_ENV}", "[]")
-    requests = json.loads(raw)
-    out = {}
-    for request in requests:
-        path = request["path"]
-        fmt = request.get("format")
-        expected = request["hash"]
-        try:
-            # Hash the file before any read. A file that drifted from the pin never reaches the reader, thus
-            # the extraction never gives back drifted bytes for the gate to match against.
-            actual = sha256_of(path)
-            if actual != expected:
-                out[path] = {
-                    "error": {
-                        "type": "hash-mismatch",
-                        "message": f"the pinned hash {expected} does not match the on-disk hash {actual}",
-                    }
-                }
-                continue
-            out[path] = {"rows": rows_for(path, fmt)}
-        except Exception as exc:
-            # A per-file read fault lands as a typed error, and the map still holds each other path.
-            out[path] = {"error": {"type": "read-fault", "message": str(exc)}}
-    json.dump(out, sys.stdout)
-
-
-main()
-`;

package/dist/tasks/extract-values.d.ts

@@ -1,77 +0,0 @@
-/**
- * The extraction pass on the profile rails, and the `ExtractionArm` realization over it.
- *
- * The report resolver falls through to this arm for an over-cap file or a host parse fault. The arm runs one
- * fixed extraction script in an ephemeral sandbox, and it gives back the rows that the script read. No agent
- * loop runs anywhere in this path. A file whose extension names no tabular format never arrives here,
- * because the host decides the format and it refuses the file before the fall-through.
- *
- * The pass runs inside the step of the tool call that resolves the report (`sandbox/step-sandbox.ts`), under
- * the auth of that call, and it mints no mandate. One call can run more than one pass, thus the exec of each
- * pass takes the key of the step and a hash of its requests. The container is ephemeral, and it goes away
- * with the work, thus no standing machine exists.
- */
-import type { Result } from "neverthrow";
-import type { AuthContext, Identity } from "../auth/types.js";
-import type { Logger } from "../lib/logger.js";
-import type { ExtractionArm, ExtractionArtifact, ExtractionRequest } from "../report-model/production-resolver.js";
-import type { SandboxClient } from "../sandbox/client.js";
-import type { SuspendingRefusal } from "../sandbox/sandbox-error.js";
-import type { ExecRequest, ExecResult } from "../sandbox/types.js";
-import { type ExtractValuesResult } from "./extract-values-script.js";
-/** The construction deps of the pass. It shares the sandbox rail of the profile. */
-export type ExtractionDeps = {
-    readonly sandboxClient: SandboxClient;
-    /** Operational logging seam. An absent logger falls back to a no-op. */
-    readonly logger?: Logger;
-};
-/** The caller of one pass: the analysis that it reads, and the identity and the auth of the tool call. */
-export type ExtractionCaller = {
-    readonly analysisId: string;
-    readonly identity: Identity;
-    readonly auth: AuthContext;
-};
-/**
- * Build the sandbox exec for one extraction pass. The command runs the fixed script through `python3 -c`.
- * The working directory is the analysis mount, thus a relative request path reads the correct file. The
- * request list rides in one environment variable.
- *
- * Each request carries its pinned hash. Thus the script can hash the file first and refuse a file that
- * drifted from the pin, before the read gives back drifted bytes.
- *
- * Each request also carries the format that the host decided. The script obeys that format, thus this arm
- * derives no reader from an extension and the two arms can never read one file two ways.
- *
- * The function is pure, thus a test asserts the command shape without a sandbox.
- */
-export declare function buildExtractionExec(analysisId: string, requests: readonly ExtractionRequest[]): ExecRequest;
-/**
- * Parse the script output from the exec result. A synthetic failure, a timeout, and a non-zero exit each
- * throw, because each means the script did not emit its map. A stdout that is not the map shape throws too.
- *
- * The function is pure, thus a test asserts the parse without a sandbox. The arm turns the throw into a
- * rejected promise.
- */
-export declare function parseExtractionOutput(result: ExecResult): ExtractValuesResult;
-/**
- * Run one extraction pass: make the container, run the script on every request, and remove the container.
- *
- * A suspending refusal of the spawn is the `err`, and the caller reports it. Each other fault throws.
- */
-export declare function runExtraction(deps: ExtractionDeps, caller: ExtractionCaller, requests: readonly ExtractionRequest[]): Promise<Result<ExtractValuesResult, SuspendingRefusal>>;
-/** Runs one extraction pass for the bound analysis, and gives the raw value map back, or the refusal of its sandbox. */
-export type ExtractionRunner = (requests: readonly ExtractionRequest[]) => Promise<Result<ExtractValuesResult, SuspendingRefusal>>;
-/**
- * Turn the raw script output into the arm result. A path with rows enters the map. A path with an error
- * drops out, thus the reference at that path reads as an unread artifact, which the seam contract expects.
- *
- * The function is pure, thus a test asserts the mapping without a sandbox.
- */
-export declare function extractionArtifactsFromResult(result: ExtractValuesResult): Map<string, ExtractionArtifact>;
-/**
- * Make the extraction arm over a runner. One `extract` call makes one run with every request in it, and it
- * gives the value map. A run fault rejects the promise, and the resolver turns the rejection into a failed
- * reference. A refusal of the sandbox with the suspend flag is the `err`, and the resolver reports its reason on each
- * reference.
- */
-export declare function createExtractionArm(run: ExtractionRunner): ExtractionArm;

package/dist/tasks/extract-values.js

@@ -1,146 +0,0 @@
-/**
- * The extraction pass on the profile rails, and the `ExtractionArm` realization over it.
- *
- * The report resolver falls through to this arm for an over-cap file or a host parse fault. The arm runs one
- * fixed extraction script in an ephemeral sandbox, and it gives back the rows that the script read. No agent
- * loop runs anywhere in this path. A file whose extension names no tabular format never arrives here,
- * because the host decides the format and it refuses the file before the fall-through.
- *
- * The pass runs inside the step of the tool call that resolves the report (`sandbox/step-sandbox.ts`), under
- * the auth of that call, and it mints no mandate. One call can run more than one pass, thus the exec of each
- * pass takes the key of the step and a hash of its requests. The container is ephemeral, and it goes away
- * with the work, thus no standing machine exists.
- */
-import { createHash } from "node:crypto";
-import { createNoopLogger } from "../lib/console-logger.js";
-import { safeParseJsonAs } from "../lib/parse-json.js";
-import { passSpawnSession, withStepSandbox } from "../sandbox/step-sandbox.js";
-import { EXTRACTION_INPUT_ENV, EXTRACTION_SCRIPT, ExtractValuesResultSchema } from "./extract-values-script.js";
-/** The synthetic run id and step id of the extraction pass. Both are constants shared by every analysis. */
-const EXTRACT_VALUES_RUN_LITERAL = "extract-values";
-const EXTRACT_VALUES_STEP_LITERAL = "extract";
-/** The provenance agent id. No agent loop runs, thus this names the extraction pass, not a model agent. */
-const EXTRACT_VALUES_AGENT_ID = "value-extractor";
-/** The exec budget for one extraction pass. It matches the profile budget. */
-const EXTRACTION_DEADLINE_MS = 300_000;
-/**
- * The container size for one extraction pass. The fall-through reads a file that is over the host cap, thus
- * the container needs headroom to load the file into pandas. The size is fixed, because the seam request
- * carries no file size. A later change can size it from the batch.
- */
-const EXTRACTION_RESOURCES = { cpu: 2, memoryGb: 8 };
-/**
- * Build the sandbox exec for one extraction pass. The command runs the fixed script through `python3 -c`.
- * The working directory is the analysis mount, thus a relative request path reads the correct file. The
- * request list rides in one environment variable.
- *
- * Each request carries its pinned hash. Thus the script can hash the file first and refuse a file that
- * drifted from the pin, before the read gives back drifted bytes.
- *
- * Each request also carries the format that the host decided. The script obeys that format, thus this arm
- * derives no reader from an extension and the two arms can never read one file two ways.
- *
- * The function is pure, thus a test asserts the command shape without a sandbox.
- */
-export function buildExtractionExec(analysisId, requests) {
-    return {
-        command: ["python3", "-c", EXTRACTION_SCRIPT],
-        cwd: `/${analysisId}`,
-        env: { [EXTRACTION_INPUT_ENV]: JSON.stringify(scriptRequests(requests)) },
-        timeoutSeconds: Math.floor(EXTRACTION_DEADLINE_MS / 1000),
-    };
-}
-function scriptRequests(requests) {
-    return requests.map((request) => ({ path: request.path, format: request.format, hash: request.hash }));
-}
-/** The key of one pass inside its step: the same requests give the same exec, and other requests a new one. */
-function requestKey(requests) {
-    return createHash("sha256")
-        .update(JSON.stringify(scriptRequests(requests)), "utf8")
-        .digest("hex")
-        .slice(0, 16);
-}
-/**
- * Parse the script output from the exec result. A synthetic failure, a timeout, and a non-zero exit each
- * throw, because each means the script did not emit its map. A stdout that is not the map shape throws too.
- *
- * The function is pure, thus a test asserts the parse without a sandbox. The arm turns the throw into a
- * rejected promise.
- */
-export function parseExtractionOutput(result) {
-    if (result.syntheticFailure !== undefined) {
-        throw new Error(`the extraction sandbox failed: ${result.syntheticFailure.reason}`);
-    }
-    if (result.timedOut) {
-        throw new Error("the extraction sandbox reached the deadline");
-    }
-    if (result.exitCode !== 0) {
-        throw new Error(`the extraction script exited with code ${String(result.exitCode)}`);
-    }
-    let parsed;
-    try {
-        parsed = safeParseJsonAs(result.stdout, ExtractValuesResultSchema);
-    }
-    catch {
-        throw new Error("the extraction script did not emit valid JSON");
-    }
-    if (!parsed.success)
-        throw parsed.error;
-    return parsed.data;
-}
-/**
- * Run one extraction pass: make the container, run the script on every request, and remove the container.
- *
- * A suspending refusal of the spawn is the `err`, and the caller reports it. Each other fault throws.
- */
-export async function runExtraction(deps, caller, requests) {
-    const logger = (deps.logger ?? createNoopLogger()).named("extract-values").with({ analysisId: caller.analysisId });
-    try {
-        const ran = await withStepSandbox(deps.sandboxClient, {
-            session: passSpawnSession(caller, {
-                analysisId: caller.analysisId,
-                runId: EXTRACT_VALUES_RUN_LITERAL,
-                stepId: EXTRACT_VALUES_STEP_LITERAL,
-                agentId: EXTRACT_VALUES_AGENT_ID,
-            }),
-            // The pass only reads, thus the container mounts the analysis tree read-only.
-            spec: { resources: EXTRACTION_RESOURCES, readOnly: true },
-            execKey: requestKey(requests),
-        }, logger, async (exec) => parseExtractionOutput(await exec(buildExtractionExec(caller.analysisId, requests), EXTRACTION_DEADLINE_MS)));
-        if (ran.isErr())
-            logger.warn("the host refused the sandbox of the extraction", { reason: ran.error.reason });
-        return ran;
-    }
-    catch (cause) {
-        logger.error("extraction failed", logger.errorFields(cause));
-        throw cause;
-    }
-}
-/**
- * Turn the raw script output into the arm result. A path with rows enters the map. A path with an error
- * drops out, thus the reference at that path reads as an unread artifact, which the seam contract expects.
- *
- * The function is pure, thus a test asserts the mapping without a sandbox.
- */
-export function extractionArtifactsFromResult(result) {
-    const out = new Map();
-    for (const [path, outcome] of Object.entries(result)) {
-        if ("rows" in outcome) {
-            out.set(path, { rows: outcome.rows });
-        }
-    }
-    return out;
-}
-/**
- * Make the extraction arm over a runner. One `extract` call makes one run with every request in it, and it
- * gives the value map. A run fault rejects the promise, and the resolver turns the rejection into a failed
- * reference. A refusal of the sandbox with the suspend flag is the `err`, and the resolver reports its reason on each
- * reference.
- */
-export function createExtractionArm(run) {
-    return {
-        async extract(requests) {
-            return (await run(requests)).map(extractionArtifactsFromResult);
-        },
-    };
-}

package/dist/tools/report-session/derive-table.d.ts

@@ -1,164 +0,0 @@
-/**
- * The derivation tool of a report session.
- *
- * A run writes statistical tables, and not plot-ready ones. This tool reshapes the pinned evidence into one
- * table that a block can bind: a join, a pivot, or an aggregate. The agent writes the script, and the record
- * chains the derived table back to the evidence that made it.
- *
- * A session derivation is not an analysis run. It mints no run id, no mandate, and no artifact, and it writes
- * under the session directory alone. The rails are the rails of the value tier (`tasks/extract-values.ts`):
- * one ephemeral container inside the step of the call (`sandbox/step-sandbox.ts`), which goes away with the
- * work. The container stays until the record lands, thus a rerun of the step before the record adopts the
- * container and the exec record of the first attempt, and the script does not run again. A rerun after the
- * record finds the record of its call, and it gives that table back.
- *
- * The container mounts the analysis tree read-only, and one write mount covers the `derived/` directory of
- * the session alone. The script writes its table into that mount directly, thus a large table makes no
- * roundtrip and no write of the script can reach the workspace tree. The working directory of the exec is
- * that same mount, and the standard output carries the logs of the script alone.
- *
- * The host then reads the file that the container wrote. A path inside the mount is still untrusted bytes: a
- * script can leave a symbolic link in place of its output. Thus the host classifies the file against the
- * workspace root before it hashes one byte, and an escape refuses as typed data.
- *
- * Each declared input must sit in the served membership, and its hash comes from there. The declaration is
- * what the record pins, thus a derived cell traces to a pinned artifact and to the script that read it.
- *
- * The tool refuses an output name that the membership already holds. A record is immutable, and a second
- * derivation of one table takes a new name.
- *
- * A composition with no sandbox client cannot derive at all. The tool reports that condition one time, up
- * front, the same discipline as the eyes. A per-attempt failure would instead read as a transient fault, and
- * it would invite a repeat of a call that can never pass.
- */
-import { z } from "zod";
-import { type Logger } from "../../lib/logger.js";
-import type { SandboxClient } from "../../sandbox/client.js";
-import type { ExecRequest, ExecResult } from "../../sandbox/types.js";
-import type { DerivationSource, ReportSessionStateStore } from "../../state/report-session-state.js";
-import { type ResolveWorkspaceRoot } from "../../workspace/paths.js";
-import { type Tool } from "../define-tool.js";
-import { type ReportSessionStateGateway, type SessionRefusal } from "../report-authoring/authoring-tools.js";
-import { type ProvenanceSeam } from "../../provenance/seam.js";
-/** The input of one derivation: the script, the declared pinned inputs, and the name of the output file. */
-declare const deriveTableInput: z.ZodObject<{
-    script: z.ZodString;
-    inputs: z.ZodArray<z.ZodString>;
-    output: z.ZodString;
-}, z.core.$strip>;
-export type DeriveTableInput = z.infer<typeof deriveTableInput>;
-/**
- * The typed outcome of the derivation tool. Each arm is ok-channel data, thus the tool never throws for one
- * of them.
- *
- * `derived` carries the workspace-relative path of the derived table, its content hash, the hash of the
- * script, the sources that the record pins, and the header columns of the output. Each other arm names a
- * condition that the agent repairs: a call that is out of bounds, an input that the membership does not
- * hold, a name that a record already holds, a script that failed in the container, and a green script that
- * left no file at the output name.
- */
-export type DeriveTableResult = {
-    outcome: "refused";
-    refusal: SessionRefusal;
-} | {
-    outcome: "unavailable";
-    detail: string;
-} | {
-    outcome: "script-too-large";
-    bytes: number;
-    cap: number;
-    detail: string;
-} | {
-    outcome: "too-many-inputs";
-    count: number;
-    cap: number;
-    detail: string;
-} | {
-    outcome: "unsafe-name";
-    detail: string;
-} | {
-    outcome: "absent-input";
-    path: string;
-    detail: string;
-} | {
-    outcome: "repeated-name";
-    outputPath: string;
-    detail: string;
-} | {
-    outcome: "exec-failed";
-    detail: string;
-} | {
-    outcome: "suspended";
-    reason: string;
-    detail: string;
-} | {
-    outcome: "no-output";
-    detail: string;
-} | {
-    outcome: "derived";
-    path: string;
-    hash: string;
-    scriptHash: string;
-    sources: DerivationSource[];
-    columns?: string[];
-};
-/**
- * The construction deps of the derivation tool.
- *
- * `derivations` is the append side of the durable session state, thus the record lands beside the document
- * and the pin. `sandboxClient` is the rail of the exec, and a composition that binds none leaves the session
- * with no derivation at all. `resolveWorkspaceRoot` maps the analysis of the call onto its workspace root,
- * thus one singleton tool serves every analysis.
- */
-export type DeriveTableToolDeps = {
-    readonly gateway: ReportSessionStateGateway;
-    readonly resolveWorkspaceRoot: ResolveWorkspaceRoot;
-    readonly derivations: Pick<ReportSessionStateStore, "appendDerivation">;
-    readonly sandboxClient?: SandboxClient;
-    /** The provenance seam; an unbound session emit emits nothing and the derivation runs the same. */
-    readonly provenance?: ProvenanceSeam;
-    readonly logger?: Logger;
-};
-/** The environment variable that carries the declared inputs into the container. */
-export declare const DERIVE_INPUT_ENV = "DERIVE_INPUTS";
-/** The environment variable that carries the container path of the output file into the container. */
-export declare const DERIVE_OUTPUT_ENV = "DERIVE_OUTPUT";
-/** One declared input, as the container reads it: the mounted path of the file, and its pinned hash. */
-export type DerivationInputMount = {
-    readonly path: string;
-    readonly hash: string;
-};
-/**
- * Build the sandbox exec of one derivation. The command clears the output path, and then it runs the script
- * of the agent through `python3 -c`.
- *
- * The working directory is the write mount, thus the script writes its table beside where it stands. Each
- * declared input rides as its mounted path, thus the script opens the file wherever it works from. The
- * output path rides too, thus the script names no directory of its own.
- *
- * The function is pure, thus a test asserts the command shape without a sandbox.
- */
-export declare function buildDerivationExec(args: {
-    readonly script: string;
-    readonly workingDir: string;
-    readonly inputs: readonly DerivationInputMount[];
-    readonly output: string;
-}): ExecRequest;
-/**
- * Give the failure of an exec result, or `undefined` when the script ran to a clean exit.
- *
- * A synthetic failure, a timeout, and a non-zero exit each mean that no table came back. The detail of a
- * non-zero exit carries the tail of the standard error, thus the agent repairs the script from what the
- * container reported.
- *
- * The function is pure, thus a test asserts the mapping without a sandbox.
- */
-export declare function describeExecFailure(result: ExecResult): string | undefined;
-/**
- * Make the derivation tool over the session-state gateway, the derivation ledger, and the sandbox rails.
- *
- * The tool reads the thread id from the scope of the call, and it loads the membership through the gateway.
- * Thus one factory serves every thread, and the tool holds no per-session value.
- */
-export declare function createDeriveTableTool(deps: DeriveTableToolDeps): Tool<DeriveTableInput, DeriveTableResult>;
-export {};