Introduce core infrastructure for generating typed TypeScript SDK files:

- src/codegen.ts: Code generation utilities that convert fetched tools
  into TypeScript interfaces and wrapper functions. Generates both
  types.d.ts (type definitions) and index.ts (implementation) files.

- src/dynamic-client.ts: Lightweight RPC client for executing tools
  via the StackOne /actions/rpc endpoint. Used by generated SDK files
  to execute tools with proper authentication and request formatting.

Key features:
- JSON Schema to TypeScript type conversion
- Automatic interface generation from tool parameters
- PascalCase/camelCase naming conventions
- Support for enum, oneOf, anyOf, allOf schemas
- Optional parameter handling

Add generateTypedClient() method to StackOneToolSet that fetches tools
and generates typed TypeScript SDK files. This provides a convenient
API for generating account-specific typed clients.

Changes:
- Export generateTypedClientContent, GenerateTypedClientOptions from codegen
- Export DynamicToolClient, DynamicToolClientConfig from dynamic-client
- Add StackOneToolSet.generateTypedClient() method that:
  - Fetches tools using existing fetchTools() infrastructure
  - Generates types.d.ts and index.ts files via writeTypedClientFiles()
  - Returns generated file paths and content

Relocate the dynamic tools generation script from scripts/ to examples/
to better reflect its purpose as a usage example rather than a build
script.

The script demonstrates how to use StackOneToolSet.generateTypedClient()
to create typed TypeScript SDKs from tools fetched via MCP. It now uses
the new integrated API instead of directly calling codegen functions.

- Add STACKONE_ACCOUNT_IDS to .env_example for typed SDK generation
- Update bun.lock with dependency changes

DynamicToolClient is only used as a type annotation in generated
wrapper functions, so use import type for proper type-only imports.

Replace custom JSON Schema to TypeScript conversion with the `untyped`
library for more reliable and better-formatted type generation.

Benefits:
- Proper JSDoc comment formatting with multi-line support
- Nested object properties get their own JSDoc descriptions
- Better indentation and readability
- @required tags for required properties
- Maintained enum simplification (>20 values → base type)

Changes:
- Add untyped dependency for schema processing
- Rewrite codegen.ts to convert JSON Schema to untyped input format
- Make generateTypedClientContent async (untyped uses async resolution)
- Update stackone.ts to await the now-async generation

…lient

The RPC endpoint (/actions/rpc) does not support unified API actions
(prefixed with 'unified_'). This change adds automatic detection and
routing for unified actions to call the REST API directly instead.

The parseUnifiedAction function converts action names to HTTP methods
and URL paths:
- unified_hris_list_employees -> GET /unified/hris/employees
- unified_hris_get_employees -> GET /unified/hris/employees/{id}
- unified_hris_create_employees -> POST /unified/hris/employees
- unified_hris_update_employees -> PATCH /unified/hris/employees/{id}
- unified_hris_list_employees_documents -> GET /unified/hris/employees/{id}/documents

Non-unified actions continue to use the RPC endpoint as before.

Added ai-code-generation.ts example that demonstrates:
- Generating typed client files from StackOne tool catalog via generateTypedClient()
- Using Claude (Haiku 4.5) with structured output (Zod schema) for code generation
- Executing generated TypeScript code against StackOne APIs

Key improvements in code quality:
- Uses Bun.env with type-safe module augmentation instead of process.env
- Uses generateObject() from Vercel AI SDK for structured JSON output, eliminating
  markdown code block parsing hacks
- Proper Zod schema validation for generated code structure
- Cleaner environment variable handling with nullish coalescing (??)

The example showcases the full workflow: typed client generation → AI code
generation with structured output → code execution and result display.

Change buildQueryString to recursively handle nested objects like
filter parameters. Instead of JSON.stringify, now uses bracket
notation (e.g., filter[updated_after]=xxx) which is the expected
format for the StackOne API.

- Add caching for typed client generation (skip if files exist)
- Add --no-cache flag to force regeneration
- Save run history with timestamps (generated code + output JSON)
- Remove explanation field from schema (reduce tokens)
- Remove baseUrl fallback from prompt (reduce tokens)
- Clean up temporary _generated-code.ts after execution
- Switch from Sonnet 4.5 to Haiku 4.5 for code generation
- Add sample runs from test account (421095649644)
- Exclude generated-dynamic-tools from biome linting

Add run example demonstrating Promise.all for fetching department groups
and work locations simultaneously with summary generation.

Query: "Get all department groups and all work locations in parallel,
then show a summary"