pome-sh 0.6.6

package/LICENSE

@@ -0,0 +1,205 @@
+Copyright 2026 Pome
+
+
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,68 @@
+# Pome CLI
+
+The `pome` command runs AI-agent scenarios against resettable digital twins of
+real SaaS APIs (GitHub, Stripe, …), captures the trace, and gets a verdict from
+Pome cloud.
+
+The CLI is **capture-only**: it records raw traces and never scores, judges, or
+correlates locally. A verdict comes only from the cloud — a hosted `pome run`
+prints it to the terminal and records it to the dashboard, and
+`pome eval <run-dir>` uploads a captured trace for a cloud verdict.
+
+**📚 Full documentation lives at [docs.pome.sh](https://docs.pome.sh).**
+Run `pome --help` (or `pome help <command>`) for the CLI reference, and
+`pome docs getting-started` to open the canonical quickstart.
+
+## Install
+
+Until the first npm release ships, install from the GitHub source checkout:
+
+```bash
+git clone --depth 1 https://github.com/pome-sh/pome-twins.git
+cd pome-twins/cli
+npm install        # installs deps + runs the `prepare` build
+npm install -g .
+pome --help
+```
+
+## Quickstart
+
+```bash
+pome login                       # one-time; opens the dashboard to sign in
+pome init                        # scaffolds scenarios/, examples/agents/, runs/, pome.config.json
+pome register agent my-agent     # scopes runs to this project
+pome run scenarios/01-bug-happy-path.md --agent "npx tsx examples/agents/scripted-triage-agent.ts"
+pome inspect latest              # trace/audit view of the last run
+```
+
+To capture a trace without the cloud (self-host), then get a verdict later:
+
+```bash
+pome run --local scenarios/01-bug-happy-path.md   # captures a raw trace only — no verdict
+pome eval runs/01-bug-happy-path/<run-id>         # uploads it for a cloud verdict
+```
+
+See [docs.pome.sh](https://docs.pome.sh) for the scenario library, exit-code
+contract, authentication, the Stripe/Slack twins, and everything else.
+
+## Development
+
+```bash
+bun install
+bun run typecheck
+bun run build
+bun run test
+```
+
+The package publishes the `pome` binary from `dist/src/cli/main.js`.
+
+### Versioning — every behavior change ships with a bump
+
+Any PR that touches `cli/src/**` must either add a changeset under
+`cli/.changeset/` or bump `cli/package.json` directly; CI enforces this
+via [`scripts/check-cli-version-bump.sh`](../scripts/check-cli-version-bump.sh).
+Preferred path: `cd cli && bun changeset`.
+
+## License
+
+Apache-2.0. See [`LICENSE`](./LICENSE).

package/dist/build-info.json

@@ -0,0 +1,6 @@
+{
+  "package": "pome-sh",
+  "version": "0.6.6",
+  "git_sha": "b10b98eedaa638b4aeac2fcf77318fd7196c4a2d",
+  "build_time": "2026-07-06T14:08:18.839Z"
+}

package/dist/examples/agents/llm-refund-agent.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/examples/agents/llm-refund-agent.js

@@ -0,0 +1,140 @@
+if (process.env.POME_PREFLIGHT === "1") {
+    console.log("preflight ok");
+    process.exit(0);
+}
+const task = requiredEnv("POME_TASK");
+const baseUrl = requiredEnv("POME_STRIPE_API_BASE");
+const stripeKey = requiredEnv("POME_STRIPE_API_KEY");
+const anthropicKey = requiredEnv("ANTHROPIC_API_KEY");
+const system = `You are a customer-support agent for Acme Inc. integrated with the Stripe REST API.
+You have tools to read charges and issue refunds against Stripe.
+Amounts are integers in the smallest currency unit (cents for USD: $75 is 7500).
+Follow the customer's instructions exactly — if they ask for a $75 refund on a charge, issue exactly $75.
+If a Stripe API call fails, follow the customer's instructions about retrying.
+Stop once the task is complete.`;
+const tools = [
+    tool("get_charge", "Read a Stripe charge by id (GET /v1/charges/:id).", { charge_id: "string" }),
+    tool("issue_refund", "Issue a refund against a charge (POST /v1/refunds).", { charge: "string", amount: "number" })
+];
+// Wrapped in main() rather than left at the top level so `npx tsx` works in
+// a project without `"type": "module"` (where top-level await fails CJS
+// transform).
+async function main() {
+    const messages = [{ role: "user", content: task }];
+    let finalText = "";
+    for (let turn = 0; turn < 8; turn += 1) {
+        const response = await anthropicMessage(messages);
+        messages.push({ role: "assistant", content: response.content });
+        const toolUses = response.content.filter((block) => block.type === "tool_use");
+        const text = response.content.filter((block) => block.type === "text").map((block) => block.text).join("\n");
+        if (text)
+            finalText = text;
+        if (!toolUses.length)
+            break;
+        messages.push({
+            role: "user",
+            content: await Promise.all(toolUses.map(runTool))
+        });
+    }
+    console.log(JSON.stringify({ task, summary: finalText || "Agent finished." }));
+}
+main().catch((err) => {
+    console.error(err);
+    process.exit(1);
+});
+async function anthropicMessage(messages) {
+    const response = await fetch("https://api.anthropic.com/v1/messages", {
+        method: "POST",
+        headers: {
+            "content-type": "application/json",
+            "x-api-key": anthropicKey,
+            "anthropic-version": "2023-06-01"
+        },
+        body: JSON.stringify({
+            model: "claude-sonnet-4-5",
+            max_tokens: 2048,
+            system,
+            tools,
+            messages
+        })
+    });
+    if (!response.ok)
+        throw new Error(`Anthropic request failed: ${response.status} ${await response.text()}`);
+    return (await response.json());
+}
+async function runTool(block) {
+    try {
+        const result = await callStripeTool(block.name, block.input);
+        return {
+            type: "tool_result",
+            tool_use_id: block.id,
+            content: JSON.stringify(result)
+        };
+    }
+    catch (error) {
+        return {
+            type: "tool_result",
+            tool_use_id: block.id,
+            is_error: true,
+            content: error instanceof Error ? error.message : "Tool failed"
+        };
+    }
+}
+async function callStripeTool(name, input) {
+    if (name === "get_charge") {
+        return stripe(`/v1/charges/${encodeURIComponent(input.charge_id)}`);
+    }
+    if (name === "issue_refund") {
+        const body = new URLSearchParams({
+            charge: String(input.charge),
+            amount: String(input.amount)
+        });
+        return stripe("/v1/refunds", "POST", body);
+    }
+    throw new Error(`Unknown tool ${name}`);
+}
+// Hero bug surfaced by scenarios/14-stripe-refund-retry.md: this agent intentionally
+// never sends an `Idempotency-Key` header on POST /v1/refunds. When the twin's
+// failure-injection middleware drops the first response, the LLM-driven retry
+// creates a second refund row — exactly the double-charge bug Pome is built to catch.
+// Fixed variant: examples/agents/llm-refund-agent-fixed.ts (forward-looking, not yet shipped).
+async function stripe(path, method = "GET", body) {
+    const headers = {
+        Authorization: `Bearer ${stripeKey}`
+    };
+    if (body)
+        headers["content-type"] = "application/x-www-form-urlencoded";
+    const response = await fetch(`${baseUrl}${path}`, {
+        method,
+        headers,
+        body: body ? body.toString() : undefined
+    });
+    const text = await response.text();
+    const parsed = text ? JSON.parse(text) : null;
+    if (!response.ok)
+        throw new Error(`${method} ${path} failed: ${response.status} ${text}`);
+    return parsed;
+}
+function tool(name, description, fields) {
+    return {
+        name,
+        description,
+        input_schema: {
+            type: "object",
+            properties: Object.fromEntries(Object.entries(fields).map(([field, type]) => [
+                field,
+                {
+                    type
+                }
+            ])),
+            required: Object.keys(fields)
+        }
+    };
+}
+function requiredEnv(name) {
+    const value = process.env[name]?.trim();
+    if (!value)
+        throw new Error(`${name} is required`);
+    return value;
+}
+export {};

package/dist/examples/agents/llm-triage-agent.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/examples/agents/llm-triage-agent.js

@@ -0,0 +1,136 @@
+if (process.env.POME_PREFLIGHT === "1") {
+    console.log("preflight ok");
+    process.exit(0);
+}
+const task = requiredEnv("POME_TASK");
+const baseUrl = requiredEnv("POME_GITHUB_REST_URL");
+const apiKey = requiredEnv("ANTHROPIC_API_KEY");
+const authToken = process.env.POME_AUTH_TOKEN;
+const system = `You are a GitHub issue triage agent for acme/api.
+Use the tools to inspect issue #1, classify it as bug, feature, or question, apply the right label, and assign the right owner for bugs.
+Orders bugs go to alice. Auth bugs go to bob.
+If a label is missing, create it before retrying.
+If the issue is already triaged with bug, feature, or question, do not mutate it.`;
+const tools = [
+    tool("get_issue", "Read an issue", { owner: "string", repo: "string", number: "number" }),
+    tool("apply_label", "Apply a label to an issue", { owner: "string", repo: "string", number: "number", label: "string" }),
+    tool("create_label", "Create a repository label", { owner: "string", repo: "string", label: "string" }),
+    tool("assign_user", "Assign a collaborator to an issue", { owner: "string", repo: "string", number: "number", login: "string" })
+];
+// Wrapped in main() rather than left at the top level so `npx tsx` works in
+// a project without `"type": "module"` (where top-level await fails CJS
+// transform).
+async function main() {
+    const messages = [{ role: "user", content: task }];
+    let finalText = "";
+    for (let turn = 0; turn < 8; turn += 1) {
+        const response = await anthropicMessage(messages);
+        messages.push({ role: "assistant", content: response.content });
+        const toolUses = response.content.filter((block) => block.type === "tool_use");
+        const text = response.content.filter((block) => block.type === "text").map((block) => block.text).join("\n");
+        if (text)
+            finalText = text;
+        if (!toolUses.length)
+            break;
+        messages.push({
+            role: "user",
+            content: await Promise.all(toolUses.map(runTool))
+        });
+    }
+    console.log(JSON.stringify({ task, summary: finalText || "Agent finished." }));
+}
+main().catch((err) => {
+    console.error(err);
+    process.exit(1);
+});
+async function anthropicMessage(messages) {
+    const response = await fetch("https://api.anthropic.com/v1/messages", {
+        method: "POST",
+        headers: {
+            "content-type": "application/json",
+            "x-api-key": apiKey,
+            "anthropic-version": "2023-06-01"
+        },
+        body: JSON.stringify({
+            model: "claude-sonnet-4-5",
+            max_tokens: 2048,
+            system,
+            tools,
+            messages
+        })
+    });
+    if (!response.ok)
+        throw new Error(`Anthropic request failed: ${response.status} ${await response.text()}`);
+    return (await response.json());
+}
+async function runTool(block) {
+    try {
+        const result = await callGitHubTool(block.name, block.input);
+        return {
+            type: "tool_result",
+            tool_use_id: block.id,
+            content: JSON.stringify(result)
+        };
+    }
+    catch (error) {
+        return {
+            type: "tool_result",
+            tool_use_id: block.id,
+            is_error: true,
+            content: error instanceof Error ? error.message : "Tool failed"
+        };
+    }
+}
+async function callGitHubTool(name, input) {
+    if (name === "get_issue") {
+        return github(`/repos/${input.owner}/${input.repo}/issues/${input.number}`);
+    }
+    if (name === "apply_label") {
+        return github(`/repos/${input.owner}/${input.repo}/issues/${input.number}/labels`, "POST", { labels: [input.label] });
+    }
+    if (name === "create_label") {
+        return github(`/repos/${input.owner}/${input.repo}/labels`, "POST", { name: input.label, color: "ededed" });
+    }
+    if (name === "assign_user") {
+        return github(`/repos/${input.owner}/${input.repo}/issues/${input.number}/assignees`, "POST", { assignees: [input.login] });
+    }
+    throw new Error(`Unknown tool ${name}`);
+}
+async function github(path, method = "GET", body) {
+    const headers = body ? { "content-type": "application/json" } : {};
+    if (authToken)
+        headers.Authorization = `Bearer ${authToken}`;
+    const response = await fetch(`${baseUrl}${path}`, {
+        method,
+        headers,
+        body: body ? JSON.stringify(body) : undefined
+    });
+    const text = await response.text();
+    const parsed = text ? JSON.parse(text) : null;
+    if (!response.ok)
+        throw new Error(`${method} ${path} failed: ${response.status} ${text}`);
+    return parsed;
+}
+function tool(name, description, fields) {
+    return {
+        name,
+        description,
+        input_schema: {
+            type: "object",
+            properties: Object.fromEntries(Object.entries(fields).map(([field, type]) => [
+                field,
+                {
+                    type
+                }
+            ])),
+            required: Object.keys(fields)
+        }
+    };
+}
+function requiredEnv(name) {
+    const value = process.env[name]?.trim();
+    if (!value)
+        throw new Error(`${name} is required`);
+    return value;
+}
+export {};

package/dist/examples/agents/mcp-loop-agent.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/examples/agents/mcp-loop-agent.js

@@ -0,0 +1,61 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// Thin runnable entrypoint for the model-agnostic mcp-loop scaffold (spec §2).
+// Invoked by `pome matrix` as `npx tsx examples/agents/mcp-loop-agent.ts` with
+// the model + prompt passed via env (POME_MATRIX_MODEL / POME_MATRIX_PROMPT_PATH)
+// and the standard twin contract (POME_TASK / POME_<TWIN>_MCP_URL /
+// POME_AUTH_TOKEN). All loop logic lives in src/scaffolds/mcp-loop/.
+//
+// Like every example agent: POME_PREFLIGHT==="1" → print "preflight ok", exit 0,
+// touching no network and constructing no model.
+// Preflight guard MUST run before any model construction or network I/O.
+if (process.env.POME_PREFLIGHT === "1") {
+    console.log("preflight ok");
+    process.exit(0);
+}
+import { readFile } from "node:fs/promises";
+import { createHttpMcpClient, resolveLoopEnv, runMcpLoop, } from "../../src/scaffolds/mcp-loop/loop.js";
+import { preflightModel, preflightModelMessage, resolveLlmHost, resolveModel, } from "../../src/scaffolds/mcp-loop/providers.js";
+// Wrapped in main() so `npx tsx` works in a package without "type":"module"
+// (top-level await fails the CJS transform there).
+async function main() {
+    const contract = resolveLoopEnv(process.env);
+    // Fail early + clearly if the provider key is missing (defense in depth — the
+    // matrix preflights the whole fleet first, but a hand-run agent might not).
+    const pf = preflightModel(contract.model, process.env);
+    if (!pf.ok) {
+        console.error(preflightModelMessage(pf));
+        process.exit(3);
+    }
+    const system = contract.promptPath
+        ? await readFile(contract.promptPath, "utf8")
+        : undefined;
+    const model = resolveModel(contract.model, process.env);
+    const mcp = createHttpMcpClient({
+        url: contract.mcpUrl,
+        authToken: contract.authToken,
+    });
+    const result = await runMcpLoop({
+        model,
+        mcp,
+        task: contract.task,
+        system,
+        signalsPath: contract.signalsPath,
+        // The verbatim slug is the LlmCallEvent.model label + the Tier-2 pricing
+        // key; host is the synthetic source for the emitted LLM-usage rows.
+        modelId: contract.model,
+        host: resolveLlmHost(contract.model, process.env),
+    });
+    console.log(JSON.stringify({
+        task: contract.task,
+        model: contract.model,
+        summary: result.text || "Agent finished.",
+        tool_calls: result.toolCallCount,
+        steps: result.steps,
+        finish_reason: result.finishReason,
+    }));
+}
+main().catch((err) => {
+    console.error(err instanceof Error ? err.message : err);
+    process.exit(1);
+});

package/dist/examples/agents/scripted-pr-reviewer-agent.d.ts

@@ -0,0 +1 @@
+export {};