@pikku/addon-ollama 0.1.2 → 0.1.3

package/dist/.pikku/workflow/pikku-workflow-types.gen.ts

@@ -1,5 +1,5 @@
 /**
- * This file was generated by @pikku/cli@0.12.55
+ * This file was generated by @pikku/cli@0.12.96
  */
 import { WorkflowCancelledException } from '@pikku/core/workflow'
 import { template } from '@pikku/core/workflow'
@@ -8,12 +8,17 @@ import {
   type PikkuWorkflowGraphConfig,
   type PikkuWorkflowGraphResult,
 } from '@pikku/core/workflow'
-import type { PikkuWorkflowWire, WorkflowStepOptions } from '@pikku/core/workflow'
+import type { PikkuWorkflowWire, PikkuScenarioWire, WorkflowStepOptions, ScenarioStepOptions } from '@pikku/core/workflow'
 
 export { WorkflowCancelledException }
 import type { PikkuFunctionSessionless, PikkuFunctionConfig } from '../function/pikku-function-types.gen.js'
 import type { FlattenedRPCMap } from '../rpc/pikku-rpc-wirings-map.internal.gen.d.js'
 import type { FlattenedWorkflowMap } from './pikku-workflow-map.gen.d.js'
+import type { AgentMap as FlattenedAgentMap } from '../agent/pikku-agent-map.gen.d.js'
+import type { FlattenedScenarioStepMap } from './pikku-scenario-step-map.gen.d.js'
+import type { TypedPersonas } from './pikku-personas.gen.js'
+
+export type { TypedPersonas }
 
 export { template }
 
@@ -39,8 +44,48 @@ export interface TypedWorkflow extends PikkuWorkflowWire {
   ): Promise<T>
 }
 
+/**
+ * The typed half of a scenario wire: `step` and its `given`/`when`/`then`
+ * sugar, narrowed to the names declared by `pikkuScenarioStep` in this project.
+ * The phase only changes the prose the reporter renders.
+ */
+export interface TypedScenarioSteps {
+  step<K extends keyof FlattenedScenarioStepMap>(
+    stepName: string,
+    stepFunc: K,
+    data?: FlattenedScenarioStepMap[K]['input'],
+    options?: ScenarioStepOptions
+  ): Promise<FlattenedScenarioStepMap[K]['output']>
+
+  given<K extends keyof FlattenedScenarioStepMap>(
+    stepName: string,
+    stepFunc: K,
+    data?: FlattenedScenarioStepMap[K]['input'],
+    options?: ScenarioStepOptions
+  ): Promise<FlattenedScenarioStepMap[K]['output']>
+
+  when<K extends keyof FlattenedScenarioStepMap>(
+    stepName: string,
+    stepFunc: K,
+    data?: FlattenedScenarioStepMap[K]['input'],
+    options?: ScenarioStepOptions
+  ): Promise<FlattenedScenarioStepMap[K]['output']>
+
+  then<K extends keyof FlattenedScenarioStepMap>(
+    stepName: string,
+    stepFunc: K,
+    data?: FlattenedScenarioStepMap[K]['input'],
+    options?: ScenarioStepOptions
+  ): Promise<FlattenedScenarioStepMap[K]['output']>
+}
+
+export type TypedScenario = TypedWorkflow &
+  Omit<PikkuScenarioWire, keyof PikkuWorkflowWire | keyof TypedScenarioSteps> &
+  TypedScenarioSteps
+
 import type { StandardSchemaV1 } from '@standard-schema/spec'
 import type { InferSchemaOutput, PikkuPermission, PikkuMiddleware, NodeConfig, PikkuApprovalDescription } from '../function/pikku-function-types.gen.js'
+import type { ScopeId } from '../scopes/pikku-scopes.gen.js'
 import { PikkuError } from '@pikku/core/errors'
 import type { CorePermissionGroup } from '@pikku/core'
 
@@ -49,6 +94,11 @@ export type PikkuFunctionWorkflow<
   Out = never
 > = PikkuFunctionSessionless<In, Out, 'workflow'>
 
+export type PikkuFunctionScenario<
+  In = unknown,
+  Out = never
+> = PikkuFunctionSessionless<In, Out, 'scenario' | 'actors'>
+
 export type PikkuWorkflowConfigWithSchema<
   InputSchema extends StandardSchemaV1 | undefined = undefined,
   OutputSchema extends StandardSchemaV1 | undefined = undefined
@@ -70,6 +120,11 @@ export type PikkuWorkflowConfigWithSchema<
     OutputSchema extends StandardSchemaV1 ? InferSchemaOutput<OutputSchema> : unknown
   >
   auth?: boolean
+  /**
+   * Scopes the session must hold to run this workflow. All of them are required
+   * (AND), and they are checked before `permissions`.
+   */
+  scopes?: ScopeId[]
   permissions?: InputSchema extends StandardSchemaV1 ? CorePermissionGroup<PikkuPermission<InferSchemaOutput<InputSchema>>> : undefined
   middleware?: PikkuMiddleware[]
   input?: InputSchema
@@ -109,6 +164,361 @@ export function pikkuWorkflowComplexFunc(func: any) {
   return typeof func === 'function' ? { func } : func
 }
 
+export type PikkuScenarioConfigWithSchema<
+  InputSchema extends StandardSchemaV1 | undefined = undefined,
+  OutputSchema extends StandardSchemaV1 | undefined = undefined
+> = Omit<PikkuWorkflowConfigWithSchema<InputSchema, OutputSchema>, 'func' | 'auth' | 'scopes' | 'permissions'> & {
+  func: PikkuFunctionScenario<
+    InputSchema extends StandardSchemaV1 ? InferSchemaOutput<InputSchema> : unknown,
+    OutputSchema extends StandardSchemaV1 ? InferSchemaOutput<OutputSchema> : unknown
+  >
+  /**
+   * Runs before the scenario body. Same signature as `func`, but its return
+   * value is discarded — a hook is setup, not a step, so it is never recorded
+   * on the ladder. Throwing skips the body and fails the run; `after` still
+   * runs.
+   */
+  before?: PikkuScenarioHook<InputSchema>
+  /**
+   * Always runs after the scenario body, in a `finally`, whether it passed or
+   * failed. Throwing fails a run that would otherwise have passed; on an
+   * already-failed run it attaches as the `cause` and never replaces the
+   * original error.
+   */
+  after?: PikkuScenarioHook<InputSchema>
+  /**
+   * Why this scenario is held out of a default run, stated where the scenario
+   * is. The scenario still appears in the plan and is reported as skipped
+   * rather than quietly omitted; naming it directly with `--flows` runs it
+   * anyway.
+   */
+  skip?: string
+}
+
+/**
+ * A scenario lifecycle hook: the scenario's own `(services, data, wire)`
+ * signature with its result discarded.
+ */
+export type PikkuScenarioHook<
+  InputSchema extends StandardSchemaV1 | undefined = undefined
+> = PikkuFunctionScenario<
+  InputSchema extends StandardSchemaV1 ? InferSchemaOutput<InputSchema> : unknown,
+  void
+>
+
+/**
+ * Declares a scenario hook. Returns the function verbatim — a hook is never
+ * registered, so this exists purely to give an inline hook a call site to be
+ * contextually typed from, the way every other pikku primitive is.
+ */
+export function pikkuScenarioHook<In = unknown>(
+  hook: PikkuFunctionScenario<In, void>
+): PikkuFunctionScenario<In, void> {
+  return hook
+}
+
+/**
+ * A scenario: a complex workflow that drives the app the way users do.
+ * Steps run as actors over the REAL transport — `scenario.do(step, rpc,
+ * data, { actor: actors.yasser })` — so flows double as e2e tests and
+ * staged/production health checks (no state reset; scope what you create).
+ */
+export function pikkuScenario<
+  InputSchema extends StandardSchemaV1 | undefined = undefined,
+  OutputSchema extends StandardSchemaV1 | undefined = undefined
+>(
+  config: PikkuScenarioConfigWithSchema<InputSchema, OutputSchema>
+): PikkuFunctionConfig<InputSchema extends StandardSchemaV1 ? InferSchemaOutput<InputSchema> : unknown, OutputSchema extends StandardSchemaV1 ? InferSchemaOutput<OutputSchema> : unknown, 'scenario' | 'actors', PikkuFunctionScenario<InputSchema extends StandardSchemaV1 ? InferSchemaOutput<InputSchema> : unknown, OutputSchema extends StandardSchemaV1 ? InferSchemaOutput<OutputSchema> : unknown>, InputSchema, OutputSchema>
+export function pikkuScenario<In, Out = unknown>(
+  func:
+    | PikkuFunctionScenario<In, Out>
+    | PikkuFunctionConfig<In, Out, 'scenario' | 'actors', PikkuFunctionScenario<In, Out>>
+): PikkuFunctionConfig<In, Out, 'scenario' | 'actors'>
+export function pikkuScenario(func: any) {
+  return typeof func === 'function' ? { func } : func
+}
+
+/**
+ * A scenario as a feature references it. Any `pikkuScenario` export is
+ * assignable; `In` is recovered from it so the paired form's `data` is
+ * checked against that scenario's own input.
+ */
+export type PikkuScenarioRef<In = any, Out = any> = PikkuFunctionConfig<
+  In,
+  Out,
+  'scenario' | 'actors',
+  PikkuFunctionScenario<In, Out>,
+  any,
+  any
+>
+
+/**
+ * One entry in a feature's `scenarios` list, validated against itself: a bare
+ * scenario, or a scenario paired with the input to run it with. The paired form
+ * is gherkin's `Examples:` written as an ordinary loop.
+ */
+export type PikkuFeatureEntry<Entry> = Entry extends {
+  scenario: PikkuScenarioRef<infer In>
+}
+  ? { scenario: PikkuScenarioRef<In>; data: In }
+  : Entry extends PikkuScenarioRef
+    ? Entry
+    : never
+
+export type PikkuFeatureConfig<Scenarios extends readonly unknown[]> = {
+  /** Human-readable name. The export identifier is the id. */
+  name: string
+  description?: string
+  tags?: string[]
+  scenarios: { [K in keyof Scenarios]: PikkuFeatureEntry<Scenarios[K]> }
+  /**
+   * Runs ONCE before the whole group — not before each scenario. Per-scenario
+   * setup is the scenario's own `before`; gherkin's `Background:` is
+   * deliberately not expressible here.
+   */
+  before?: PikkuScenarioHook
+  after?: PikkuScenarioHook
+}
+
+/**
+ * A feature: an ordered group of scenarios, mirroring gherkin's Feature ↔
+ * Scenario structure. Scenarios are referenced by imported identifier, so a
+ * renamed or deleted scenario is a compile error rather than a silent skip.
+ *
+ * A scenario does not have to belong to a feature — a void-input scenario
+ * still runs standalone.
+ *
+ * ```ts
+ * export const credentialFeature = pikkuFeature({
+ *   name: 'Credential API',
+ *   tags: ['credential'],
+ *   before: startsMockOAuthServer,
+ *   after: stopsMockOAuthServer,
+ *   scenarios: [
+ *     credentialLazyLoadScenario,
+ *     ...['stripe', 'google'].map((name) => ({
+ *       scenario: credentialRoundTripScenario,
+ *       data: { name },
+ *     })),
+ *   ],
+ * })
+ * ```
+ */
+export function pikkuFeature<const Scenarios extends readonly unknown[]>(
+  config: PikkuFeatureConfig<Scenarios>
+): PikkuFeatureConfig<Scenarios> {
+  return config
+}
+
+/**
+ * One surface's implementation of a step.
+ *
+ * Each binding is typed independently, so a browser binding gets a non-optional
+ * `wire.browser` and a cli binding a non-optional `wire.cli` without either
+ * leaking into the other.
+ */
+export type PikkuFunctionScenarioStep<
+  In = unknown,
+  Out = never,
+  Surface extends 'browser' | 'cli' | 'default' = 'default'
+> = PikkuFunctionSessionless<
+  In,
+  Out,
+  Surface extends 'default' ? 'scenarioStep' : 'scenarioStep' | Surface
+>
+
+export type PikkuScenarioStepConfigWithSchema<
+  InputSchema extends StandardSchemaV1 | undefined = undefined,
+  OutputSchema extends StandardSchemaV1 | undefined = undefined
+> = {
+  /** Registered name — this is the string `scenario.step()` references. */
+  name: string
+  /**
+   * What this step does, for the console and for whoever reads the source. It
+   * is also the fallback prose when no `template` is declared, in which case a
+   * reporter renders "Given the shopper buys an apple". Defaults to the call
+   * site's step name.
+   */
+  description?: string
+  /**
+   * The prose a reporter renders for this step, with `{placeholders}` filled
+   * from the input the step was called with — `'sees {packageName}'` reports as
+   * "Then the admin sees @pikku/addon-todos". Every input field should appear,
+   * so the report names the values under test rather than repeating one
+   * sentence per call site.
+   */
+  template?: string
+  title?: string
+  tags?: string[]
+  input?: InputSchema
+  output?: OutputSchema
+  errors?: Array<typeof PikkuError>
+  /**
+   * Drive this step through a real browser, as a human would. The runner
+   * provisions a window for the step's actor first — which makes an actor
+   * mandatory — and `wire.browser` is non-optional inside it.
+   *
+   * Compose shared utilities here rather than writing raw clicks: the step says
+   * what the actor is doing, the utilities say how.
+   */
+  browser?: PikkuFunctionScenarioStep<
+    InputSchema extends StandardSchemaV1 ? InferSchemaOutput<InputSchema> : unknown,
+    OutputSchema extends StandardSchemaV1 ? InferSchemaOutput<OutputSchema> : unknown,
+    'browser'
+  >
+  /** Drive this step remotely, over the websocket. */
+  cli?: PikkuFunctionScenarioStep<
+    InputSchema extends StandardSchemaV1 ? InferSchemaOutput<InputSchema> : unknown,
+    OutputSchema extends StandardSchemaV1 ? InferSchemaOutput<OutputSchema> : unknown,
+    'cli'
+  >
+  /**
+   * The server-side path — the fast suite, and the floor every other surface
+   * falls back to.
+   *
+   * On a `then`, this is not an alternative to the other bindings but a second
+   * **witness**: the run executes every binding it has and fails if they
+   * disagree, because "the row says paid" and "the page says paid" are different
+   * claims and the gap between them is the bug nobody catches.
+   */
+  default?: PikkuFunctionScenarioStep<
+    InputSchema extends StandardSchemaV1 ? InferSchemaOutput<InputSchema> : unknown,
+    OutputSchema extends StandardSchemaV1 ? InferSchemaOutput<OutputSchema> : unknown,
+    'default'
+  >
+}
+
+export type PikkuScenarioStepConfig<In, Out> =
+  Omit<PikkuScenarioStepConfigWithSchema<undefined, undefined>, 'browser' | 'cli' | 'default' | 'input' | 'output'> & {
+    browser?: PikkuFunctionScenarioStep<In, Out, 'browser'>
+    cli?: PikkuFunctionScenarioStep<In, Out, 'cli'>
+    default?: PikkuFunctionScenarioStep<In, Out, 'default'>
+  }
+
+/**
+ * A named, reusable scenario step, declaring one implementation per surface an
+ * actor can drive it through.
+ *
+ * The step's identity is what the actor is trying to do; which surface carries
+ * it out is a binding. That is what lets one ladder run through a real browser,
+ * over the websocket, or entirely server-side — and what makes "how much of this
+ * flow can a human actually reach" a number rather than a guess.
+ *
+ * Steps are deliberately NOT registered as RPCs: a browser-driving step must
+ * never be network-callable.
+ */
+export function pikkuScenarioStep<
+  InputSchema extends StandardSchemaV1 | undefined = undefined,
+  OutputSchema extends StandardSchemaV1 | undefined = undefined
+>(
+  config: PikkuScenarioStepConfigWithSchema<InputSchema, OutputSchema>
+): PikkuFunctionConfig<InputSchema extends StandardSchemaV1 ? InferSchemaOutput<InputSchema> : unknown, OutputSchema extends StandardSchemaV1 ? InferSchemaOutput<OutputSchema> : unknown, 'scenarioStep' | 'browser' | 'cli', PikkuFunctionScenarioStep<InputSchema extends StandardSchemaV1 ? InferSchemaOutput<InputSchema> : unknown, OutputSchema extends StandardSchemaV1 ? InferSchemaOutput<OutputSchema> : unknown, 'browser' | 'cli' | 'default'>, InputSchema, OutputSchema>
+export function pikkuScenarioStep<In, Out = unknown>(
+  config: PikkuScenarioStepConfig<In, Out>
+): PikkuFunctionConfig<In, Out, 'scenarioStep' | 'browser' | 'cli'>
+export function pikkuScenarioStep(config: any) {
+  const surfaces = (['browser', 'cli', 'default'] as const).filter(
+    (surface) => typeof config[surface] === 'function'
+  )
+  if (surfaces.length === 0) {
+    throw new Error(
+      `[scenario] step '${config.name}' declares no surface bindings. Add at least a \`default\` (server-side) implementation.`
+    )
+  }
+  return {
+    ...config,
+    surfaces,
+    // The runner sets the surface on the wire and calls this once per binding it
+    // resolved — every witness of a `then`, exactly one for an action step.
+    func: (services: any, data: any, wire: any) => {
+      const surface = wire?.scenarioStep?.surface ?? 'default'
+      const binding = config[surface] ?? config.default
+      return binding(services, data, wire)
+    },
+  }
+}
+
+/**
+ * What a step declares when nobody drives it: one implementation, and no
+ * surfaces to choose between.
+ *
+ * `func` rather than `default` is the point. `default` means *the fallback when
+ * no other surface applies*, which implies others could exist; `func` says
+ * structurally that there is one way this happens. That also keeps the phase
+ * rule coherent — an assertion runs every witness it has and fails if they
+ * disagree, and this has exactly one by construction.
+ */
+export type PikkuSubjectScenarioStepConfigWithSchema<
+  InputSchema extends StandardSchemaV1 | undefined = undefined,
+  OutputSchema extends StandardSchemaV1 | undefined = undefined
+> = Omit<
+  PikkuScenarioStepConfigWithSchema<InputSchema, OutputSchema>,
+  'browser' | 'cli' | 'default'
+> & {
+  func: PikkuFunctionScenarioStep<
+    InputSchema extends StandardSchemaV1 ? InferSchemaOutput<InputSchema> : unknown,
+    OutputSchema extends StandardSchemaV1 ? InferSchemaOutput<OutputSchema> : unknown,
+    'default'
+  >
+}
+
+export type PikkuSubjectScenarioStepConfig<In, Out> =
+  Omit<PikkuScenarioStepConfig<In, Out>, 'browser' | 'cli' | 'default'> & {
+    func: PikkuFunctionScenarioStep<In, Out, 'default'>
+  }
+
+/**
+ * A step in which the app acts on itself — "Given the platform has expired the
+ * trial".
+ *
+ * The grammatical subject of that sentence is not a user of your app; it **is**
+ * your app, which is why it is its own declaration rather than a persona with an
+ * asterisk. A persona is a person.
+ *
+ * Local-test-only, and never in a virtual user's catalogue: a virtual user that
+ * could expire its own trial is manufacturing the outcome it exists to discover.
+ */
+export function pikkuPlatformScenarioStep<
+  InputSchema extends StandardSchemaV1 | undefined = undefined,
+  OutputSchema extends StandardSchemaV1 | undefined = undefined
+>(
+  config: PikkuSubjectScenarioStepConfigWithSchema<InputSchema, OutputSchema>
+): PikkuFunctionConfig<InputSchema extends StandardSchemaV1 ? InferSchemaOutput<InputSchema> : unknown, OutputSchema extends StandardSchemaV1 ? InferSchemaOutput<OutputSchema> : unknown, 'scenarioStep', PikkuFunctionScenarioStep<InputSchema extends StandardSchemaV1 ? InferSchemaOutput<InputSchema> : unknown, OutputSchema extends StandardSchemaV1 ? InferSchemaOutput<OutputSchema> : unknown, 'default'>, InputSchema, OutputSchema>
+export function pikkuPlatformScenarioStep<In, Out = unknown>(
+  config: PikkuSubjectScenarioStepConfig<In, Out>
+): PikkuFunctionConfig<In, Out, 'scenarioStep'>
+export function pikkuPlatformScenarioStep(config: any) {
+  return { ...config, surfaces: ['default'] }
+}
+
+/**
+ * A step in which a third-party system acts — "Given Stripe's webhook arrives",
+ * "When Mailgun bounces it".
+ *
+ * `addon` names the addon that wraps that service, the same name its
+ * `wireAddon` declares. These steps *are* the mock its consumers currently
+ * hand-write: shipped by the addon author, maintained with the addon, and the
+ * same artifact that appears in the prose.
+ *
+ * Note that arranging and asserting are different — "Stripe's webhook arrives"
+ * stubs, "Then Stripe was charged" asserts, and only the first is a stub.
+ *
+ * Local-test-only, and never in a virtual user's catalogue: one that could
+ * invoke this would forge its own payment success.
+ */
+export function pikkuAddonScenarioStep<
+  InputSchema extends StandardSchemaV1 | undefined = undefined,
+  OutputSchema extends StandardSchemaV1 | undefined = undefined
+>(
+  config: PikkuSubjectScenarioStepConfigWithSchema<InputSchema, OutputSchema> & { addon: string }
+): PikkuFunctionConfig<InputSchema extends StandardSchemaV1 ? InferSchemaOutput<InputSchema> : unknown, OutputSchema extends StandardSchemaV1 ? InferSchemaOutput<OutputSchema> : unknown, 'scenarioStep', PikkuFunctionScenarioStep<InputSchema extends StandardSchemaV1 ? InferSchemaOutput<InputSchema> : unknown, OutputSchema extends StandardSchemaV1 ? InferSchemaOutput<OutputSchema> : unknown, 'default'>, InputSchema, OutputSchema>
+export function pikkuAddonScenarioStep<In, Out = unknown>(
+  config: PikkuSubjectScenarioStepConfig<In, Out> & { addon: string }
+): PikkuFunctionConfig<In, Out, 'scenarioStep'>
+export function pikkuAddonScenarioStep(config: any) {
+  return { ...config, surfaces: ['default'] }
+}
+
 type TypedRef<T> = { $ref: string; path?: string } & { __phantomType?: T }
 
 type TemplateString = {
@@ -125,13 +535,19 @@ type InputWithRefs<T> = {
 type NodeInputType<FuncMap extends Record<string, string>, K extends keyof FuncMap> =
   FuncMap[K] extends keyof FlattenedRPCMap
     ? InputWithRefs<FlattenedRPCMap[FuncMap[K]]['input']>
-    : Record<string, unknown>
+    : FuncMap[K] extends keyof FlattenedWorkflowMap
+      ? InputWithRefs<FlattenedWorkflowMap[FuncMap[K]]['input']>
+      : Record<string, unknown>
 
 type NodeOutputKeys<FuncMap extends Record<string, string>, N extends string> =
   N extends keyof FuncMap
     ? FuncMap[N] extends keyof FlattenedRPCMap
       ? keyof FlattenedRPCMap[FuncMap[N]]['output'] & string
-      : string
+      : FuncMap[N] extends keyof FlattenedWorkflowMap
+        ? keyof FlattenedWorkflowMap[FuncMap[N]]['output'] & string
+        : FuncMap[N] extends keyof FlattenedAgentMap
+          ? keyof FlattenedAgentMap[FuncMap[N]]['output'] & string
+          : string
     : string
 
 type RefFunction<FuncMap extends Record<string, string>> = {
@@ -139,6 +555,7 @@ type RefFunction<FuncMap extends Record<string, string>> = {
     nodeId: N,
     path: NodeOutputKeys<FuncMap, N>
   ): TypedRef<unknown>
+  <N extends Extract<keyof FuncMap, string>>(nodeId: N): TypedRef<unknown>
   (nodeId: 'trigger' | '$item', path?: string): TypedRef<unknown>
 }
 
@@ -152,13 +569,20 @@ type GraphNodeConfigMap<FuncMap extends Record<string, string>> = {
       | (() => NodeInputType<FuncMap, K>)
       | ((ref: RefFunction<FuncMap>, template: TemplateFunction) => NodeInputType<FuncMap, K>)
     onError?: Extract<keyof FuncMap, string> | Extract<keyof FuncMap, string>[]
+    /** Free-text node documentation. Non-semantic — excluded from graphHash. */
+    notes?: string
   }
 }
 
 type NextConfig<NodeIds extends string> = NodeIds | NodeIds[] | { if: string; then: NodeIds; else?: NodeIds }
 
 export function pikkuWorkflowGraph<
-  const FuncMap extends Record<string, keyof FlattenedRPCMap & string>
+  const FuncMap extends Record<
+    string,
+    | (keyof FlattenedRPCMap & string)
+    | (keyof FlattenedWorkflowMap & string)
+    | (keyof FlattenedAgentMap & string)
+  >
 >(
   config: PikkuWorkflowGraphConfig<FuncMap, GraphNodeConfigMap<FuncMap>>
 ): PikkuWorkflowGraphResult {

package/dist/.pikku/workflow/pikku-workflow-wirings-meta.gen.js

@@ -1,5 +1,5 @@
 /**
- * This file was generated by @pikku/cli@0.12.55
+ * This file was generated by @pikku/cli@0.12.96
  */
 import { pikkuState } from '@pikku/core/internal';
 const workflowsMeta = {};

package/dist/.pikku/workflow/pikku-workflow-wirings-meta.gen.js.map

@@ -1 +1 @@
-{"version":3,"file":"pikku-workflow-wirings-meta.gen.js","sourceRoot":"","sources":["../../../.pikku/workflow/pikku-workflow-wirings-meta.gen.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAA;AAGjD,MAAM,aAAa,GAA6B,EAAE,CAAA;AAElD,UAAU,CAAC,qBAAqB,EAAE,WAAW,EAAE,MAAM,EAAE,aAAa,CAAC,CAAA"}
+{"version":3,"file":"pikku-workflow-wirings-meta.gen.js","sourceRoot":"","sources":["../../../.pikku/workflow/pikku-workflow-wirings-meta.gen.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAA;AAGjD,MAAM,aAAa,GAAyB,EAAE,CAAA;AAE9C,UAAU,CAAC,qBAAqB,EAAE,WAAW,EAAE,MAAM,EAAE,aAAa,CAAC,CAAA"}

package/dist/.pikku/workflow/pikku-workflow-wirings-meta.gen.ts

@@ -1,9 +1,9 @@
 /**
- * This file was generated by @pikku/cli@0.12.55
+ * This file was generated by @pikku/cli@0.12.96
  */
 import { pikkuState } from '@pikku/core/internal'
-import type { SerializedWorkflowGraphs } from '@pikku/inspector/workflow-graph'
+import type { WorkflowsRuntimeMeta } from '@pikku/core/workflow/types'
 
-const workflowsMeta: SerializedWorkflowGraphs = {}
+const workflowsMeta: WorkflowsRuntimeMeta = {}
 
 pikkuState('@pikku/addon-ollama', 'workflows', 'meta', workflowsMeta)

package/dist/.pikku/workflow/pikku-workflow-wirings.gen.d.ts

@@ -1,5 +1,5 @@
 export {};
 /**
- * This file was generated by @pikku/cli@0.12.55
+ * This file was generated by @pikku/cli@0.12.96
  */
 //# sourceMappingURL=pikku-workflow-wirings.gen.d.ts.map

package/dist/.pikku/workflow/pikku-workflow-wirings.gen.js

@@ -1,5 +1,5 @@
 export {};
 /**
- * This file was generated by @pikku/cli@0.12.55
+ * This file was generated by @pikku/cli@0.12.96
  */
 //# sourceMappingURL=pikku-workflow-wirings.gen.js.map

package/dist/.pikku/workflow/pikku-workflow-wirings.gen.ts

@@ -1,3 +1,3 @@
 /**
- * This file was generated by @pikku/cli@0.12.55
+ * This file was generated by @pikku/cli@0.12.96
  */

package/dist/src/functions/embeddings/embed-many.function.d.ts

@@ -28,7 +28,7 @@ export declare const ollamaEmbedMany: import("#pikku").PikkuFunctionConfig<{
     usage: {
         tokens: number;
     };
-}, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<{
+}, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<{
     model: string;
     values: string[];
 }, {
@@ -36,5 +36,5 @@ export declare const ollamaEmbedMany: import("#pikku").PikkuFunctionConfig<{
     usage: {
         tokens: number;
     };
-}, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;
+}, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
 //# sourceMappingURL=embed-many.function.d.ts.map

package/dist/src/functions/embeddings/embed-many.function.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"embed-many.function.d.ts","sourceRoot":"","sources":["../../../../src/functions/embeddings/embed-many.function.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,oBAAoB;;;iBAG/B,CAAA;AAEF,eAAO,MAAM,WAAW;;iBAEtB,CAAA;AAEF,eAAO,MAAM,qBAAqB;;;;;iBAGhC,CAAA;AAIF,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;uEAe1B,CAAA"}
+{"version":3,"file":"embed-many.function.d.ts","sourceRoot":"","sources":["../../../../src/functions/embeddings/embed-many.function.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,oBAAoB;;;iBAG/B,CAAA;AAEF,eAAO,MAAM,WAAW;;iBAEtB,CAAA;AAEF,eAAO,MAAM,qBAAqB;;;;;iBAGhC,CAAA;AAIF,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;4EAe1B,CAAA"}

package/dist/src/functions/embeddings/embed.function.d.ts

@@ -28,7 +28,7 @@ export declare const ollamaEmbed: import("#pikku").PikkuFunctionConfig<{
     usage: {
         tokens: number;
     };
-}, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<{
+}, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<{
     model: string;
     value: string;
 }, {
@@ -36,5 +36,5 @@ export declare const ollamaEmbed: import("#pikku").PikkuFunctionConfig<{
     usage: {
         tokens: number;
     };
-}, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;
+}, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
 //# sourceMappingURL=embed.function.d.ts.map

package/dist/src/functions/embeddings/embed.function.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"embed.function.d.ts","sourceRoot":"","sources":["../../../../src/functions/embeddings/embed.function.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,gBAAgB;;;iBAG3B,CAAA;AAEF,eAAO,MAAM,WAAW;;iBAEtB,CAAA;AAEF,eAAO,MAAM,iBAAiB;;;;;iBAG5B,CAAA;AAIF,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;uEAetB,CAAA"}
+{"version":3,"file":"embed.function.d.ts","sourceRoot":"","sources":["../../../../src/functions/embeddings/embed.function.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,gBAAgB;;;iBAG3B,CAAA;AAEF,eAAO,MAAM,WAAW;;iBAEtB,CAAA;AAEF,eAAO,MAAM,iBAAiB;;;;;iBAG5B,CAAA;AAIF,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;4EAetB,CAAA"}

package/dist/src/functions/text/generate-object.function.d.ts

@@ -23,9 +23,9 @@ export declare const OllamaGenerateObjectInput: z.ZodObject<{
     schemaName: z.ZodOptional<z.ZodString>;
     schemaDescription: z.ZodOptional<z.ZodString>;
     mode: z.ZodOptional<z.ZodEnum<{
+        json: "json";
         auto: "auto";
         tool: "tool";
-        json: "json";
     }>>;
     maxTokens: z.ZodOptional<z.ZodNumber>;
     temperature: z.ZodOptional<z.ZodNumber>;
@@ -55,7 +55,7 @@ export declare const ollamaGenerateObject: import("#pikku").PikkuFunctionConfig<
     system?: string | undefined;
     schemaName?: string | undefined;
     schemaDescription?: string | undefined;
-    mode?: "auto" | "tool" | "json" | undefined;
+    mode?: "json" | "auto" | "tool" | undefined;
     maxTokens?: number | undefined;
     temperature?: number | undefined;
 }, {
@@ -77,7 +77,7 @@ export declare const ollamaGenerateObject: import("#pikku").PikkuFunctionConfig<
     system?: string | undefined;
     schemaName?: string | undefined;
     schemaDescription?: string | undefined;
-    mode?: "auto" | "tool" | "json" | undefined;
+    mode?: "json" | "auto" | "tool" | undefined;
     maxTokens?: number | undefined;
     temperature?: number | undefined;
 }, {
@@ -88,7 +88,7 @@ export declare const ollamaGenerateObject: import("#pikku").PikkuFunctionConfig<
         completionTokens: number;
         totalTokens: number;
     };
-}, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<{
+}, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<{
     model: string;
     schema: Record<string, any>;
     prompt?: string | undefined;
@@ -99,7 +99,7 @@ export declare const ollamaGenerateObject: import("#pikku").PikkuFunctionConfig<
     system?: string | undefined;
     schemaName?: string | undefined;
     schemaDescription?: string | undefined;
-    mode?: "auto" | "tool" | "json" | undefined;
+    mode?: "json" | "auto" | "tool" | undefined;
     maxTokens?: number | undefined;
     temperature?: number | undefined;
 }, {
@@ -110,5 +110,5 @@ export declare const ollamaGenerateObject: import("#pikku").PikkuFunctionConfig<
         completionTokens: number;
         totalTokens: number;
     };
-}, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;
+}, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
 //# sourceMappingURL=generate-object.function.d.ts.map

package/dist/src/functions/text/generate-object.function.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generate-object.function.d.ts","sourceRoot":"","sources":["../../../../src/functions/text/generate-object.function.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvB,eAAO,MAAM,aAAa;;;;;;;iBAGxB,CAAA;AAEF,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;iBAWpC,CAAA;AAEF,eAAO,MAAM,WAAW;;;;iBAItB,CAAA;AAEF,eAAO,MAAM,0BAA0B;;;;;;;;iBAIrC,CAAA;AAIF,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uEAwB/B,CAAA"}
+{"version":3,"file":"generate-object.function.d.ts","sourceRoot":"","sources":["../../../../src/functions/text/generate-object.function.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvB,eAAO,MAAM,aAAa;;;;;;;iBAGxB,CAAA;AAEF,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;iBAWpC,CAAA;AAEF,eAAO,MAAM,WAAW;;;;iBAItB,CAAA;AAEF,eAAO,MAAM,0BAA0B;;;;;;;;iBAIrC,CAAA;AAIF,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4EAwB/B,CAAA"}