How long does the integration take?

Change one base URL in an OpenAI-compatible client, or install the Python or TypeScript SDK; the quickstart routes a first request in a few minutes.

Will this lock us into another vendor?

No. The router is Apache-2.0 open source, your provider keys stay yours, and the API is OpenAI-compatible, so leaving is a change of base URL.

What happens when a provider fails?

The router falls back to the next model your policy allows and records the fallback in the trace, so an outage costs a retry, not an incident.

planfunction - Prompt - OpenSmartRoute

Name: planfunction
Author: gene-png

Prompt file imported from gene-png/080426SHIELD (.claude/commands/planfunction.md). Copyright stays with the author.

Plan every function needed for the current sprint and write the plan to the next SPRINT_<n>.md (one higher than the latest existing).

Read first

Before planning anything, read:

CONTEXT.md — current state and next steps
docs/architecture.md — overall structure and data model
Existing source files to understand what already exists and what patterns are in use (apps/api/app/, apps/web/src/, e2e/)

Identify the function list

First, identify every function this sprint requires. Write a simple flat list: function names and one-sentence purpose for each.

Present this list and wait for my confirmation before deep-planning.

Parallel deep-planning

Once the function list is confirmed, spawn one subagent per function. Each subagent independently produces the full plan entry for its function:

### functionName

**File:** `src/path/to/file.ts`
**Purpose:** One sentence — what this function does and why it exists

**Parameters:**
| Name | Type | Required | Description |
|------|------|----------|-------------|
| paramName | string | yes | What it represents |

**Process:**
1. Step one — what happens first
2. Step two — what logic runs
3. Step three — what gets returned or side effect produced
Note any: validation that happens, errors that should throw, external calls made

**Returns:** `TypeName` — what it is and what it represents

**Error behaviour:** What this function throws and when. Must throw — not return null or a fallback.

**Debug log:** Where a log line should appear to confirm success

**Tests needed:**
- Happy path: [description]
- Failure case: [description]
- Edge case (if any): [description]

Each subagent also identifies: does this function depend on any other function in this sprint? Report back with the entry + dependency list.

Consolidate and write SPRINT.md

After all subagents complete, consolidate into SPRINT.md:

# Sprint Plan
_Generated: [date]_

## Goal
[One paragraph — what this sprint delivers]

## Functions to Build

[One entry per function using the format above]

## Build Order
[Ordered list — which functions to build first due to dependencies]
[Mark which functions can be built in parallel — no dependencies on each other]

## Definition of Done
- [ ] All functions implemented
- [ ] All functions type-check with `npx tsc --noEmit`
- [ ] All planned tests written and passing
- [ ] `/debugloop` run and clean
- [ ] `CONTEXT.md` updated

After writing the file, print a summary: how many functions are planned, which can be parallelized, the dependency order, and any risks you spotted.

Install planfunction and it becomes one more candidate the router can pick - when it fits.

A listing is a routing target with a manifest: what it does, which domains it covers, what it costs and who publishes it. Once installed it sits beside your own models and tools, is scored like any other candidate for each request, and shows up in the trace when it wins. Ratings come from workspaces that installed it, one per account.

Plan every function needed for the current sprint and write the plan to the next `SPRINT_<n>.md` (one higher than the latest existing). ## Read first Before planning anything, read: - `CONTEXT.md` — current state and next steps - `docs/architecture.md` — overall structure and data model - Existing source files to understand what already exists and what patterns are in use (`apps/api/app/`, `apps/web/src/`, `e2e/`) ## Identify the function list First, identify every function this sprint requires. Write a simple flat list: function names and one-sentence purpose for each. Present this list and wait for my confirmation before deep-planning. ## Parallel deep-planning Once the function list is confirmed, spawn one subagent per function. Each subagent independently produces the full plan entry for its function: ```markdown ### functionName **File:** `src/path/to/file.ts` **Purpose:** One sentence — what this function does and why it exists **Parameters:** | Name | Type | Required | Description | |------|------|----------|-------------| | paramName | string | yes | What it represents | **Process:** 1. Step one — what happens first 2. Step two — what logic runs 3. Step three — what gets returned or side effect produced Note any: validation that happens, errors that should throw, external calls made **Returns:** `TypeName` — what it is and what it represents **Error behaviour:** What this function throws and when. Must throw — not return null or a fallback. **Debug log:** Where a log line should appear to confirm success **Tests needed:** - Happy path: [description] - Failure case: [description] - Edge case (if any): [description] ``` Each subagent also identifies: does this function depend on any other function in this sprint? Report back with the entry + dependency list. ## Consolidate and write SPRINT.md After all subagents complete, consolidate into `SPRINT.md`: ```markdown # Sprint Plan _Generated: [date]_ ## Goal [One paragraph — what this sprint delivers] ## Functions to Build [One entry per function using the format above] ## Build Order [Ordered list — which functions to build first due to dependencies] [Mark which functions can be built in parallel — no dependencies on each other] ## Definition of Done - [ ] All functions implemented - [ ] All functions type-check with `npx tsc --noEmit` - [ ] All planned tests written and passing - [ ] `/debugloop` run and clean - [ ] `CONTEXT.md` updated ``` After writing the file, print a summary: how many functions are planned, which can be parallelized, the dependency order, and any risks you spotted.

{ "prompt": "Plan every function needed for the current sprint and write the plan to the next `SPRINT_<n>.md` (one higher than the latest existing).\n\n## Read first\n\nBefore planning anything, read:\n- `CONTEXT.md` — current state and next steps\n- `docs/architecture.md` — overall structure and data model\n- Existing source files to understand what already exists and what patterns are in use (`apps/api/app/`, `apps/web/src/`, `e2e/`)\n\n## Identify the function list\n\nFirst, identify every function this sprint requires. Write a simple flat list: function names and one-sentence purpose for each.\n\nPresent this list and wait for my confirmation before deep-planning.\n\n## Parallel deep-planning\n\nOnce the function list is confirmed, spawn one subagent per function. Each subagent independently produces the full plan entry for its function:\n\n```markdown\n### functionName\n\n**File:** `src/path/to/file.ts`\n**Purpose:** One sentence — what this function does and why it exists\n\n**Parameters:**\n| Name | Type | Required | Description |\n|------|------|----------|-------------|\n| paramName | string | yes | What it represents |\n\n**Process:**\n1. Step one — what happens first\n2. Step two — what logic runs\n3. Step three — what gets returned or side effect produced\nNote any: validation that happens, errors that should throw, external calls made\n\n**Returns:** `TypeName` — what it is and what it represents\n\n**Error behaviour:** What this function throws and when. Must throw — not return null or a fallback.\n\n**Debug log:** Where a log line should appear to confirm success\n\n**Tests needed:**\n- Happy path: [description]\n- Failure case: [description]\n- Edge case (if any): [description]\n```\n\nEach subagent also identifies: does this function depend on any other function in this sprint? Report back with the entry + dependency list.\n\n## Consolidate and write SPRINT.md\n\nAfter all subagents complete, consolidate into `SPRINT.md`:\n\n```markdown\n# Sprint Plan\n_Generated: [date]_\n\n## Goal\n[One paragraph — what this sprint delivers]\n\n## Functions to Build\n\n[One entry per function using the format above]\n\n## Build Order\n[Ordered list — which functions to build first due to dependencies]\n[Mark which functions can be built in parallel — no dependencies on each other]\n\n## Definition of Done\n- [ ] All functions implemented\n- [ ] All functions type-check with `npx tsc --noEmit`\n- [ ] All planned tests written and passing\n- [ ] `/debugloop` run and clean\n- [ ] `CONTEXT.md` updated\n```\n\nAfter writing the file, print a summary: how many functions are planned, which can be parallelized, the dependency order, and any risks you spotted.", "variables": [], "notes": "Plan all functions needed for the current sprint. Produces a SPRINT.md with purpose, parameters, process outline, and typed return values for each function. Tools: Read, Write, Bash(find:*).", "metadata": { "source": { "provider": "github-claude-commands", "repository": "https://github.com/gene-png/080426SHIELD", "path": ".claude/commands/planfunction.md", "ref": "0a831a7cee5ea4283e7ec8e4354855aed3b25e85", "url": "https://github.com/gene-png/080426SHIELD/blob/0a831a7cee5ea4283e7ec8e4354855aed3b25e85/.claude/commands/planfunction.md", "key": "gene-png/080426SHIELD/.claude/commands/planfunction.md" } } }

planfunction

About

Read first

Identify the function list

Parallel deep-planning

Consolidate and write SPRINT.md

Install planfunction and it becomes one more candidate the router can pick - when it fits.

What it costs to adopt - in engineering time.

One base URL

No vendor lock-in

Failover built in

Use it

Manifest

Reviews