@root-signals/scorable-cli 0.7.0 → 0.9.0

package/README.md

@@ -258,6 +258,228 @@ Options: `--page-size`, `--cursor`, `--search`, `--evaluator-id`, `--judge-id`,
 scorable execution-log get <log_id>
 ```
 
+## OTEL Trace Evaluation Filters
+
+When traces arrive at Scorable's OTLP endpoint, evaluation filters automatically run an evaluator or judge against each matching trace. Results land back on the same trace as a child span carrying the OpenTelemetry GenAI evaluation attributes (`gen_ai.evaluation.name`, `gen_ai.evaluation.score.value`, `gen_ai.evaluation.explanation`).
+
+### Create a filter
+
+```bash
+scorable otel-filter create \
+  --name "default-truthfulness" \
+  --evaluator-id <evaluator-uuid>
+```
+
+Required: `--name` and exactly one of `--evaluator-id` or `--judge-id`. A judge target emits one eval span per inner evaluator.
+
+Options: `--filter-criteria` (JSON of conditions), `--sampling-rate` (0.0–1.0, default 1.0), `--delay-seconds` (default 10, allows late spans to land before evaluation), `--inactive`
+
+Match traces from a specific service, run a 5-second-delayed evaluation:
+
+```bash
+scorable otel-filter create \
+  --name "agent-truthfulness" \
+  --evaluator-id <evaluator-uuid> \
+  --filter-criteria '{"conditions":[{"column":"resource","type":"string","key":"service.name","operator":"=","value":"my_agent"}]}' \
+  --delay-seconds 5
+```
+
+Multi-evaluator judge target:
+
+```bash
+scorable otel-filter create --name "quality-judge" --judge-id <judge-uuid>
+```
+
+### List filters
+
+```bash
+scorable otel-filter list
+```
+
+### Delete a filter
+
+```bash
+scorable otel-filter delete <filter_id>
+```
+
+### Custom extractor rules (when input/output isn't in `gen_ai.*`)
+
+For the common case the flags above are everything you need: matching traces are evaluated and their `gen_ai.input.messages` / `gen_ai.output.messages` are fed to the evaluator. If your traces don't follow that shape — Claude Code, OpenInference, custom instrumentations — you tell the evaluator where input/output live by attaching **`extractor_rules`** to the filter. Filters without `extractor_rules` keep the default behavior.
+
+Rules are carried in a YAML manifest and applied with `-f`:
+
+```bash
+scorable otel-filter create -f filter.yaml
+scorable otel-filter update <id> -f filter.yaml
+scorable otel-filter validate -f filter.yaml   # dry-run; exit 2 on schema error
+```
+
+CLI flags override values from the file when both are provided.
+
+#### Manifest shape
+
+```yaml
+name: <string>
+evaluator_id: <uuid> # exactly one of evaluator_id / judge_id
+judge_id: <uuid>
+sampling_rate: <0.0-1.0> # optional, default 1.0
+delay_seconds: <int> # optional, default 10
+is_active: <bool> # optional, default true
+filter_criteria: # which traces to evaluate (same shape as --filter-criteria)
+  conditions:
+    - column: <string> # span_name, has_error, kind, status, attribute, resource, …
+      operator: <string> # =, !=, contains, starts with, any of, none of, …
+      value: <string|number|bool>
+      key: <string> # required for "attribute" / "resource" sentinel columns
+extractor_rules: # optional; how to extract input/output from matching spans
+  - emit: <text|request_response|tool_pair|genai_messages>
+    match: # optional; same shape as filter_criteria — empty matches every span
+      conditions: [...]
+    # … emit-specific fields, see below …
+```
+
+#### `extractor_rules` reference
+
+Each rule has an `emit` kind, an optional `match` filter (same shape as `filter_criteria.conditions`), and emit-specific fields. Spans are walked in timestamp order; per span, the **first** rule whose `match` passes wins.
+
+A rule set must be able to produce both user-side and agent-side content (a `request_response` or `genai_messages` rule alone qualifies; a single `text` `role: user` rule does not). Validation rejects sets that can't.
+
+**`text`** — emit one `MessageTurn` per matching span.
+
+```yaml
+- emit: text
+  match: # optional
+    conditions:
+      - { column: span_name, operator: "=", value: claude_code.interaction }
+  role: user # user | assistant
+  locator: # where the value lives
+    kind: span_attr # span_attr | event_attr | resource_attr
+    key: user_prompt # attribute name
+    event_name: <string> # required when kind: event_attr
+    value_path: $.foo # optional JSONPath into the located value
+  tool_name: <string> # only valid when role: assistant
+```
+
+**`request_response`** — emit a user turn + an assistant turn from one span. Common when an agent stores prompt and response as flat attributes (OpenInference's `input.value` / `output.value`).
+
+```yaml
+- emit: request_response
+  match: { ... } # optional
+  input_locator: { kind: span_attr, key: input.value } # → user turn
+  output_locator: { kind: span_attr, key: output.value } # → assistant turn
+```
+
+**`tool_pair`** — emit one assistant turn per matching span carrying a tool call (input + output combined into the turn content). Built for tool-execution spans like Claude Code's `claude_code.tool` event.
+
+```yaml
+- emit: tool_pair
+  match: { ... } # optional
+  input_locator: { kind: event_attr, event_name: tool.output, key: bash_command }
+  output_locator: { kind: event_attr, event_name: tool.output, key: output }
+  tool_name: Bash # static; OR
+  tool_name_locator: { kind: span_attr, key: tool_name } # dynamic
+```
+
+**`genai_messages`** — same parsing as the default extractor, but on attribute keys you choose. Use this if your service emits the standard `gen_ai` JSON-array shape under non-default attribute names.
+
+```yaml
+- emit: genai_messages
+  match: { ... } # optional
+  input_locator: { kind: span_attr, key: my_framework.input.json }
+  output_locator: { kind: span_attr, key: my_framework.output.json }
+```
+
+#### Locator details
+
+| Field        | Meaning                                                                                           |
+| ------------ | ------------------------------------------------------------------------------------------------- |
+| `kind`       | `span_attr` (top-level), `event_attr` (inside a named event), or `resource_attr` (resource-level) |
+| `key`        | Attribute name to read                                                                            |
+| `event_name` | Only for `event_attr` — the OTel event whose attributes to read (e.g. `tool.output`)              |
+| `value_path` | Optional JSONPath into the located value; used when the attribute is itself JSON                  |
+
+#### Reference manifests
+
+`examples/otel-filters/`:
+
+- `openinference-agent.yaml` — single-span agent with `input.value` / `output.value` (`request_response`).
+- `claude-code.yaml` — Claude Code's interaction span + tool spans (`text` + `tool_pair`).
+- `genai-explicit.yaml` — gen_ai messages under custom attribute keys.
+
+## OTEL Trace Querying
+
+### List traces
+
+```bash
+scorable otel-trace list
+```
+
+Options: `--since` / `--start-time` / `--end-time` (time window), `--page-size`, `--cursor`, `--output table|json|csv` (default `table`), `--filter` (repeatable raw expression), plus convenience shortcuts below.
+
+Convenience flags — cover the common case, AND-combined with each other and with `--filter`:
+
+| Flag                    | Effect                                 |
+| ----------------------- | -------------------------------------- |
+| `--service-name <name>` | match `resource.service.name = <name>` |
+| `--has-error`           | only traces where some span errored    |
+| `--root-name <substr>`  | substring match on the root span name  |
+| `--span-name <substr>`  | substring match on any span's name     |
+| `--agent-name <name>`   | match `gen_ai.agent.name`              |
+| `--model <name>`        | match `gen_ai.request.model`           |
+| `--tool <name>`         | match `gen_ai.tool.name`               |
+
+Time-window flags (mutually exclusive group):
+
+```bash
+scorable otel-trace list --since 1h          # last hour
+scorable otel-trace list --since 7d
+scorable otel-trace list --start-time 2026-04-30T00:00:00Z --end-time 2026-05-01T00:00:00Z
+```
+
+Common one-liners:
+
+```bash
+# All traces from a specific agent in the last 24h, exported as CSV
+scorable otel-trace list --since 24h --service-name my_agent --output csv > traces.csv
+
+# Errored traces this week
+scorable otel-trace list --since 7d --has-error
+
+# Drill into traces that hit a specific tool
+scorable otel-trace list --tool fetch_customer_data
+```
+
+For anything the shortcuts don't cover, use `--filter` directly. Format: `column;type;key;operator;value`, repeatable, AND-combined. If your instrumentation follows the OpenTelemetry [GenAI semantic conventions](https://opentelemetry.io/docs/specs/semconv/registry/attributes/gen-ai/) — pydantic-ai, OpenLLMetry, Logfire, OpenAI/Anthropic SDKs with otel all do — every documented attribute is filterable without extra setup.
+
+```bash
+# Expensive runs — over 5k input tokens
+scorable otel-trace list --since 24h \
+  --filter 'gen_ai.usage.input_tokens;number;gen_ai.usage.input_tokens;>;5000'
+
+# Multi-turn conversation drill-down
+scorable otel-trace list \
+  --filter 'gen_ai.conversation.id;string;gen_ai.conversation.id;=;conv_5j66'
+
+# Filter on Scorable's own evaluation result spans
+scorable otel-trace list \
+  --filter 'gen_ai.evaluation.name;string;gen_ai.evaluation.name;=;Truthfulness'
+```
+
+See `scorable otel-trace list --help` for the full column / operator / type reference.
+
+### Inspect spans for a trace
+
+```bash
+scorable otel-trace spans <trace_id>
+```
+
+Options: `--output table|json|csv`. The JSON form returns the full span payload — attributes, events, status, kind, `resource_attributes` — which is what you typically want for debugging or piping to `jq`.
+
+```bash
+scorable otel-trace spans <trace_id> --output json | jq '.[0].span.attributes'
+scorable otel-trace spans <trace_id> --output csv > spans.csv
+```
+
 ## Prompt Testing
 
 Initialize a config file and run experiments:

package/dist/client.d.ts

@@ -1,7 +1,15 @@
-export declare function apiRequest(method: string, endpoint: string, options?: {
+interface RequestOptions {
     payload?: Record<string, unknown>;
     params?: Record<string, unknown>;
     apiKey?: string;
     baseUrl?: string;
-}): Promise<unknown>;
+}
+export interface ApiRequestResult {
+    ok: boolean;
+    status: number;
+    data: unknown;
+}
+export declare function apiRequestStatus(method: string, endpoint: string, options?: RequestOptions): Promise<ApiRequestResult>;
+export declare function apiRequest(method: string, endpoint: string, options?: RequestOptions): Promise<unknown>;
+export {};
 //# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAQA,wBAAsB,UAAU,CAC9B,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE;IACR,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAClC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,GACA,OAAO,CAAC,OAAO,CAAC,CAoDlB"}
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAQA,UAAU,cAAc;IACtB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAClC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,gBAAgB;IAC/B,EAAE,EAAE,OAAO,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,OAAO,CAAC;CACf;AAQD,wBAAsB,gBAAgB,CACpC,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE,cAAc,GACvB,OAAO,CAAC,gBAAgB,CAAC,CAoD3B;AAKD,wBAAsB,UAAU,CAC9B,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE,cAAc,GACvB,OAAO,CAAC,OAAO,CAAC,CAGlB"}

package/dist/client.js

@@ -2,7 +2,7 @@ import { createRequire } from "node:module";
 import { getApiKey, getBaseUrl } from "./auth.js";
 import { printError, printJson } from "./output.js";
 const { version } = createRequire(import.meta.url)("../package.json");
-export async function apiRequest(method, endpoint, options) {
+export async function apiRequestStatus(method, endpoint, options) {
     const apiKey = options?.apiKey ?? getApiKey();
     const baseUrl = options?.baseUrl ?? getBaseUrl();
     const seg = endpoint.endsWith("/") ? endpoint : `${endpoint}/`;
@@ -30,10 +30,10 @@ export async function apiRequest(method, endpoint, options) {
     }
     catch (e) {
         printError(`Request failed: ${e instanceof Error ? e.message : String(e)}`);
-        return null;
+        return { ok: false, status: 0, data: null };
     }
     if (response.status === 204)
-        return null;
+        return { ok: true, status: 204, data: null };
     if (!response.ok) {
         printError(`API Error: ${response.status} for ${method} ${url}`);
         try {
@@ -42,13 +42,17 @@ export async function apiRequest(method, endpoint, options) {
         catch {
             printError(`Response content: ${await response.text().catch(() => "")}`);
         }
-        return null;
+        return { ok: false, status: response.status, data: null };
     }
     try {
-        return await response.json();
+        return { ok: true, status: response.status, data: await response.json() };
     }
     catch {
         printError(`Failed to decode JSON response from API for ${url}.`);
-        return null;
+        return { ok: false, status: response.status, data: null };
     }
 }
+export async function apiRequest(method, endpoint, options) {
+    const result = await apiRequestStatus(method, endpoint, options);
+    return result.ok ? result.data : null;
+}

package/dist/commands/otel-filter/create.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+export declare function registerCreateCommand(otelFilter: Command): void;
+//# sourceMappingURL=create.d.ts.map

package/dist/commands/otel-filter/create.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create.d.ts","sourceRoot":"","sources":["../../../src/commands/otel-filter/create.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAkBpC,wBAAgB,qBAAqB,CAAC,UAAU,EAAE,OAAO,GAAG,IAAI,CA6J/D"}

package/dist/commands/otel-filter/create.js

@@ -0,0 +1,154 @@
+import fs from "node:fs";
+import ora from "ora";
+import { requireApiKey } from "../../auth.js";
+import { apiRequest } from "../../client.js";
+import { printSuccess, printError, printJson, handleSdkError } from "../../output.js";
+import { loadFilterYaml } from "../../lib/filter-yaml.js";
+export function registerCreateCommand(otelFilter) {
+    otelFilter
+        .command("create")
+        .description("Create a new OTEL trace evaluation filter. Wires either an evaluator OR a judge to incoming traces.")
+        .option("--name <name>", "Filter name")
+        .option("--evaluator-id <id>", "Evaluator UUID to run on matching traces (mutually exclusive with --judge-id)")
+        .option("--judge-id <id>", "Judge UUID to run on matching traces (mutually exclusive with --evaluator-id)")
+        .option("--filter-criteria <json>", 'Filter conditions as JSON, e.g. \'{"conditions":[{"column":"name","type":"string","key":"name","operator":"contains","value":"agent"}]}\'')
+        .option("--sampling-rate <rate>", "Sampling rate between 0.0 and 1.0")
+        .option("--delay-seconds <seconds>", "Delay before evaluation (allows late spans)")
+        .option("--inactive", "Create the filter as inactive")
+        .option("-f, --from-file <path>", "Load filter spec from a YAML/JSON file. Required only when the filter needs extractor_rules (custom input/output extraction).")
+        .addHelpText("after", `
+Target — exactly one of --evaluator-id or --judge-id is required.
+  --evaluator-id  Runs a single evaluator (one score, one justification).
+  --judge-id      Runs a judge — a bundle of evaluators that produces an
+                  aggregate verdict plus per-evaluator scores. Use this
+                  when you've already authored a judge for the agent
+                  you're tracing.
+
+Examples:
+  # Match every span and run a single evaluator
+  $ scorable otel-filter create \\
+      --name "default-truthfulness" \\
+      --evaluator-id <evaluator-uuid>
+
+  # Run a judge (multi-evaluator) on every trace from a service
+  $ scorable otel-filter create \\
+      --name "construction-quality-judge" \\
+      --judge-id <judge-uuid> \\
+      --filter-criteria '{"conditions":[{"column":"resource","type":"string","key":"service.name","operator":"=","value":"construction_assistant_agent"}]}' \\
+      --delay-seconds 5
+
+YAML manifest (only needed for custom extractor_rules):
+  When your traces don't follow the OTel GenAI shape (Claude Code, OpenInference,
+  custom instrumentations) the eval needs to be told where input/output lives.
+  Carry that mapping as extractor_rules inside a YAML file. The flag-based
+  invocation above stays unchanged for everything else.
+
+  $ scorable otel-filter create -f ./filter.yaml
+  $ scorable otel-filter create -f ./filter.yaml --inactive    # override one field
+
+  See examples/otel-filters/ for reference manifests and the README's
+  "OTEL Trace Evaluation Filters" section for the extractor_rules schema.`)
+        .action(async (opts) => {
+        let filePayload = {};
+        if (opts.fromFile) {
+            let source;
+            try {
+                source = fs.readFileSync(opts.fromFile, "utf8");
+            }
+            catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                printError(`Failed to read --from-file: ${msg}`);
+                process.exit(1);
+            }
+            try {
+                filePayload = loadFilterYaml(source);
+            }
+            catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                printError(msg);
+                process.exit(1);
+            }
+        }
+        let filterCriteria;
+        if (opts.filterCriteria) {
+            try {
+                filterCriteria = JSON.parse(opts.filterCriteria);
+            }
+            catch {
+                printError("Invalid JSON for --filter-criteria.");
+                process.exit(1);
+            }
+        }
+        let samplingRate;
+        if (opts.samplingRate !== undefined) {
+            const raw = opts.samplingRate.trim();
+            samplingRate = Number(raw);
+            if (raw === "" || !Number.isFinite(samplingRate) || samplingRate < 0 || samplingRate > 1) {
+                printError("--sampling-rate must be a number between 0.0 and 1.0.");
+                process.exit(1);
+            }
+        }
+        let delaySeconds;
+        if (opts.delaySeconds !== undefined) {
+            const raw = opts.delaySeconds.trim();
+            delaySeconds = Number(raw);
+            if (raw === "" || !Number.isInteger(delaySeconds) || delaySeconds < 0) {
+                printError("--delay-seconds must be a non-negative integer.");
+                process.exit(1);
+            }
+        }
+        const flagPayload = {};
+        if (opts.name !== undefined)
+            flagPayload.name = opts.name;
+        if (opts.evaluatorId !== undefined)
+            flagPayload.evaluator_id = opts.evaluatorId;
+        if (opts.judgeId !== undefined)
+            flagPayload.judge_id = opts.judgeId;
+        if (filterCriteria !== undefined)
+            flagPayload.filter_criteria = filterCriteria;
+        if (samplingRate !== undefined)
+            flagPayload.sampling_rate = samplingRate;
+        if (delaySeconds !== undefined)
+            flagPayload.delay_seconds = delaySeconds;
+        if (opts.inactive !== undefined)
+            flagPayload.is_active = !opts.inactive;
+        const payload = { ...filePayload, ...flagPayload };
+        if (!opts.fromFile) {
+            if (payload.sampling_rate === undefined)
+                payload.sampling_rate = 1.0;
+            if (payload.delay_seconds === undefined)
+                payload.delay_seconds = 10;
+            if (payload.is_active === undefined)
+                payload.is_active = true;
+            if (payload.filter_criteria === undefined)
+                payload.filter_criteria = {};
+        }
+        if (typeof payload.name !== "string" || payload.name.length === 0) {
+            printError("--name is required (provide via --name or --from-file).");
+            process.exit(1);
+        }
+        if (!payload.evaluator_id && !payload.judge_id) {
+            printError("Either --evaluator-id or --judge-id is required.");
+            process.exit(1);
+        }
+        if (payload.evaluator_id && payload.judge_id) {
+            printError("--evaluator-id and --judge-id are mutually exclusive.");
+            process.exit(1);
+        }
+        const spinner = ora("Creating filter...").start();
+        try {
+            const apiKey = await requireApiKey();
+            const result = await apiRequest("POST", "v1/otel/evaluation-filters", { payload, apiKey });
+            spinner.stop();
+            if (result === null) {
+                throw new Error("Filter creation failed.");
+            }
+            printSuccess("Filter created.");
+            printJson(result);
+        }
+        catch (e) {
+            spinner.stop();
+            handleSdkError(e);
+        }
+    });
+}

package/dist/commands/otel-filter/delete.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+export declare function registerDeleteCommand(otelFilter: Command): void;
+//# sourceMappingURL=delete.d.ts.map

package/dist/commands/otel-filter/delete.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delete.d.ts","sourceRoot":"","sources":["../../../src/commands/otel-filter/delete.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAMpC,wBAAgB,qBAAqB,CAAC,UAAU,EAAE,OAAO,GAAG,IAAI,CAwB/D"}

package/dist/commands/otel-filter/delete.js

@@ -0,0 +1,25 @@
+import ora from "ora";
+import { requireApiKey } from "../../auth.js";
+import { apiRequestStatus } from "../../client.js";
+import { printSuccess, handleSdkError } from "../../output.js";
+export function registerDeleteCommand(otelFilter) {
+    otelFilter
+        .command("delete <id>")
+        .description("Delete an OTEL trace evaluation filter")
+        .action(async (id) => {
+        const spinner = ora("Deleting...").start();
+        try {
+            const apiKey = await requireApiKey();
+            const { ok } = await apiRequestStatus("DELETE", `v1/otel/evaluation-filters/${encodeURIComponent(id)}`, { apiKey });
+            spinner.stop();
+            if (!ok) {
+                process.exit(1);
+            }
+            printSuccess(`Filter ${id} deleted.`);
+        }
+        catch (e) {
+            spinner.stop();
+            handleSdkError(e);
+        }
+    });
+}

package/dist/commands/otel-filter/index.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+export declare function registerOtelFilterCommands(program: Command): void;
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/otel-filter/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/commands/otel-filter/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAOpC,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAUjE"}

package/dist/commands/otel-filter/index.js

@@ -0,0 +1,15 @@
+import { registerCreateCommand } from "./create.js";
+import { registerListCommand } from "./list.js";
+import { registerDeleteCommand } from "./delete.js";
+import { registerUpdateCommand } from "./update.js";
+import { registerValidateCommand } from "./validate.js";
+export function registerOtelFilterCommands(program) {
+    const otelFilter = program
+        .command("otel-filter")
+        .description("Manage OTEL trace evaluation filters");
+    registerCreateCommand(otelFilter);
+    registerListCommand(otelFilter);
+    registerUpdateCommand(otelFilter);
+    registerDeleteCommand(otelFilter);
+    registerValidateCommand(otelFilter);
+}

package/dist/commands/otel-filter/list.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+export declare function registerListCommand(otelFilter: Command): void;
+//# sourceMappingURL=list.d.ts.map

package/dist/commands/otel-filter/list.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list.d.ts","sourceRoot":"","sources":["../../../src/commands/otel-filter/list.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAMpC,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,OAAO,GAAG,IAAI,CAwB7D"}

package/dist/commands/otel-filter/list.js

@@ -0,0 +1,29 @@
+import ora from "ora";
+import { requireApiKey } from "../../auth.js";
+import { apiRequest } from "../../client.js";
+import { printJson, handleSdkError, printMessage } from "../../output.js";
+export function registerListCommand(otelFilter) {
+    otelFilter
+        .command("list")
+        .description("List OTEL trace evaluation filters")
+        .action(async () => {
+        const spinner = ora("Fetching...").start();
+        try {
+            const apiKey = await requireApiKey();
+            const result = await apiRequest("GET", "v1/otel/evaluation-filters", { apiKey });
+            spinner.stop();
+            if (result === null) {
+                process.exit(1);
+            }
+            if (Array.isArray(result) && result.length === 0) {
+                printMessage("No filters found.");
+                return;
+            }
+            printJson(result);
+        }
+        catch (e) {
+            spinner.stop();
+            handleSdkError(e);
+        }
+    });
+}

package/dist/commands/otel-filter/update.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+export declare function registerUpdateCommand(otelFilter: Command): void;
+//# sourceMappingURL=update.d.ts.map

package/dist/commands/otel-filter/update.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"update.d.ts","sourceRoot":"","sources":["../../../src/commands/otel-filter/update.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAWpC,wBAAgB,qBAAqB,CAAC,UAAU,EAAE,OAAO,GAAG,IAAI,CAoD/D"}

package/dist/commands/otel-filter/update.js

@@ -0,0 +1,53 @@
+import fs from "node:fs";
+import ora from "ora";
+import { requireApiKey } from "../../auth.js";
+import { apiRequest } from "../../client.js";
+import { printSuccess, printError, printJson, handleSdkError } from "../../output.js";
+import { loadFilterYaml } from "../../lib/filter-yaml.js";
+export function registerUpdateCommand(otelFilter) {
+    otelFilter
+        .command("update <id>")
+        .description("Update an OTEL trace evaluation filter from a YAML/JSON manifest")
+        .requiredOption("-f, --from-file <path>", "Filter spec path (YAML or JSON)")
+        .addHelpText("after", `
+Pairs with the YAML-manifest workflow used by \`create -f\`. Edit the file,
+re-apply with this command.
+
+Example:
+  $ scorable otel-filter update <filter-id> -f ./filter.yaml`)
+        .action(async (id, opts) => {
+        let source;
+        try {
+            source = fs.readFileSync(opts.fromFile, "utf8");
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            printError(`Failed to read --from-file: ${msg}`);
+            process.exit(1);
+        }
+        let payload;
+        try {
+            payload = loadFilterYaml(source);
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            printError(msg);
+            process.exit(1);
+        }
+        const spinner = ora("Updating filter...").start();
+        try {
+            const apiKey = await requireApiKey();
+            const result = await apiRequest("PATCH", `v1/otel/evaluation-filters/${encodeURIComponent(id)}`, { payload, apiKey });
+            spinner.stop();
+            if (result === null) {
+                process.exit(1);
+            }
+            printSuccess(`Filter ${id} updated.`);
+            printJson(result);
+        }
+        catch (e) {
+            spinner.stop();
+            handleSdkError(e);
+        }
+    });
+}

package/dist/commands/otel-filter/validate.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+export declare function registerValidateCommand(otelFilter: Command): void;
+//# sourceMappingURL=validate.d.ts.map

package/dist/commands/otel-filter/validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../../src/commands/otel-filter/validate.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAYpC,wBAAgB,uBAAuB,CAAC,UAAU,EAAE,OAAO,GAAG,IAAI,CAmEjE"}