@pikku/cli 0.12.21 → 0.12.23

package/dist/src/functions/db/zod-codegen.d.ts

@@ -0,0 +1,10 @@
+export interface ZodCodegenOptions {
+    schemaFile: string;
+    outFile: string;
+}
+export interface ZodCodegenResult {
+    outFile: string;
+    written: boolean;
+    tables: string[];
+}
+export declare function generateZodTypes(options: ZodCodegenOptions): ZodCodegenResult;

package/dist/src/functions/db/zod-codegen.js

@@ -0,0 +1,109 @@
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+const INTERFACE_RE = /export\s+interface\s+(\w+)\s*\{([^}]*)\}/g;
+const FIELD_RE = /^\s*(\w+)\s*:\s*(.+?)\s*$/gm;
+export function generateZodTypes(options) {
+    const src = readFileSync(options.schemaFile, 'utf8');
+    const tables = parseTables(src);
+    const body = emitZodModule(tables);
+    let existing = null;
+    try {
+        existing = readFileSync(options.outFile, 'utf8');
+    }
+    catch {
+        // ok
+    }
+    const written = existing !== body;
+    if (written) {
+        mkdirSync(dirname(options.outFile), { recursive: true });
+        writeFileSync(options.outFile, body, 'utf8');
+    }
+    return {
+        outFile: options.outFile,
+        written,
+        tables: tables.map((table) => table.name),
+    };
+}
+function parseTables(src) {
+    const tables = [];
+    for (const match of src.matchAll(INTERFACE_RE)) {
+        const name = match[1];
+        if (name === 'DB')
+            continue;
+        const body = match[2];
+        const fields = [];
+        for (const field of body.matchAll(FIELD_RE)) {
+            fields.push({ name: field[1], type: field[2].trim() });
+        }
+        tables.push({ name, fields });
+    }
+    return tables;
+}
+function emitZodModule(tables) {
+    const lines = [];
+    lines.push('// Generated by @pikku/cli — do not edit by hand.');
+    lines.push('// Run `pikku db migrate` to refresh.');
+    lines.push('');
+    lines.push("import { z } from 'zod'");
+    lines.push('');
+    for (const table of tables) {
+        const rowFields = [];
+        const insertFields = [];
+        for (const field of table.fields) {
+            const { schema, generated } = zodForType(field.type);
+            rowFields.push(`  ${field.name}: ${schema},`);
+            insertFields.push(`  ${field.name}: ${schema}${generated ? '.optional()' : ''},`);
+        }
+        lines.push(`export const ${table.name}Z = z.object({`);
+        lines.push(...rowFields);
+        lines.push('})');
+        lines.push('');
+        lines.push(`export const ${table.name}InsertZ = z.object({`);
+        lines.push(...insertFields);
+        lines.push('})');
+        lines.push('');
+        lines.push(`export const ${table.name}PatchZ = ${table.name}Z.partial()`);
+        lines.push('');
+    }
+    return `${lines.join('\n')}\n`;
+}
+function zodForType(tsType) {
+    const generatedMatch = tsType.match(/^Generated<(.+)>$/);
+    const generated = generatedMatch !== null;
+    let inner = generated ? generatedMatch[1].trim() : tsType;
+    const nullable = inner.endsWith(' | null');
+    if (nullable) {
+        inner = inner.slice(0, -' | null'.length).trim();
+    }
+    let schema;
+    switch (inner) {
+        case 'string':
+            schema = 'z.string()';
+            break;
+        case 'number':
+            schema = 'z.number()';
+            break;
+        case 'boolean':
+            schema = 'z.boolean()';
+            break;
+        case 'Date':
+            schema = 'z.date()';
+            break;
+        case 'unknown':
+            schema = 'z.unknown()';
+            break;
+        default:
+            if (inner.endsWith('[]')) {
+                const item = zodForType(inner.slice(0, -2).trim()).schema;
+                schema = `z.array(${item})`;
+            }
+            else {
+                schema = 'z.unknown()';
+            }
+            break;
+    }
+    if (nullable) {
+        schema += '.nullable()';
+    }
+    return { schema, generated };
+}

package/dist/src/functions/runtimes/fetch/index.d.ts

@@ -1 +1 @@
-export declare const pikkuFetch: import("#pikku").PikkuFunctionConfig<void, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<void, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<void, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;
+export declare const pikkuFetch: import("#pikku").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<void, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;

package/dist/src/functions/runtimes/nextjs/pikku-command-nextjs.d.ts

@@ -1 +1 @@
-export declare const pikkuNext: import("#pikku").PikkuFunctionConfig<void, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<void, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<void, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;
+export declare const pikkuNext: import("#pikku").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<void, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;

package/dist/src/functions/runtimes/nextjs/pikku-command-nextjs.js

@@ -4,6 +4,7 @@ import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { serializeNextJsBackendWrapper as serializeNextBackendWrapper } from './serialize-nextjs-backend-wrapper.js';
+import { serializeNextJsBackendWorkerRPCWrapper as serializeNextBackendWorkerRPCWrapper } from './serialize-nextjs-backend-worker-rpc-wrapper.js';
 import { serializeNextJsHTTPWrapper as serializeNextHTTPWrapper } from './serialize-nextjs-http-wrapper.js';
 export const pikkuNext = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
@@ -20,13 +21,31 @@ export const pikkuNext = pikkuSessionlessFunc({
             return;
         }
         const visitState = await getInspectorState();
-        if (nextHTTPFile && !fetchFile) {
+        const nextBackendTransport = config.clientFiles?.nextBackendTransport ?? 'local';
+        const nextBackendFetcherImport = config.clientFiles?.nextBackendFetcherImport;
+        if ((nextHTTPFile || nextBackendTransport === 'http') && !fetchFile) {
             throw new Error('fetchFile is required in pikku config in order for nextJS http wrapper to work');
         }
         if ((nextBackendFile || nextHTTPFile) && !rpcMapDeclarationFile) {
             throw new Error('rpcMapDeclarationFile is required in pikku config in order for nextJS wrapper to work');
         }
-        if (nextBackendFile) {
+        if (nextBackendFile && nextBackendTransport === 'http') {
+            const routesMapDeclarationPath = getFileImportRelativePath(nextBackendFile, httpMapDeclarationFile, packageMappings);
+            const rpcMapDeclarationPath = getFileImportRelativePath(nextBackendFile, rpcMapDeclarationFile, packageMappings);
+            const fetchPath = getFileImportRelativePath(nextBackendFile, fetchFile, packageMappings);
+            const content = serializeNextHTTPWrapper(routesMapDeclarationPath, rpcMapDeclarationPath, fetchPath, config.globalHTTPPrefix || '', "process.env.PIKKU_DEV_MACHINE_API_BASE ?? 'http://127.0.0.1:4004'");
+            await writeFileInDir(logger, nextBackendFile, content);
+        }
+        else if (nextBackendFile && nextBackendTransport === 'worker-rpc') {
+            if (!nextBackendFetcherImport) {
+                throw new Error("clientFiles.nextBackendFetcherImport is required when nextBackendTransport === 'worker-rpc'");
+            }
+            const routesMapDeclarationPath = getFileImportRelativePath(nextBackendFile, httpMapDeclarationFile, packageMappings);
+            const rpcMapDeclarationPath = getFileImportRelativePath(nextBackendFile, rpcMapDeclarationFile, packageMappings);
+            const content = serializeNextBackendWorkerRPCWrapper(routesMapDeclarationPath, rpcMapDeclarationPath, nextBackendFetcherImport, config.globalHTTPPrefix || '');
+            await writeFileInDir(logger, nextBackendFile, content);
+        }
+        else if (nextBackendFile) {
             checkRequiredTypes(visitState.filesAndMethodsErrors, {
                 config: true,
                 singletonServicesFactory: true,

package/dist/src/functions/runtimes/nextjs/serialize-nextjs-backend-worker-rpc-wrapper.d.ts

@@ -0,0 +1 @@
+export declare const serializeNextJsBackendWorkerRPCWrapper: (routesMapPath: string, rpcMapPath: string, fetcherImportPath: string, globalHTTPPrefix?: string) => string;

package/dist/src/functions/runtimes/nextjs/serialize-nextjs-backend-worker-rpc-wrapper.js

@@ -0,0 +1,163 @@
+export const serializeNextJsBackendWorkerRPCWrapper = (routesMapPath, rpcMapPath, fetcherImportPath, globalHTTPPrefix = '') => {
+    return `'server-only'
+
+/**
+ * Worker-RPC variant of the Next.js backend wrapper. Function code is NOT
+ * loaded in-process — every call is dispatched through the injected Fetcher.
+ * Generated by @pikku/cli (nextBackendTransport: 'worker-rpc').
+ */
+import { PikkuNextJSWorkerRPC } from '@pikku/next'
+import { NextRequest } from 'next/server.js'
+import type { HTTPWiringsMap, HTTPWiringHandlerOf, HTTPWiringsWithMethod } from '${routesMapPath}'
+import type { FlattenedRPCMap } from '${rpcMapPath}'
+import { fetcher } from '${fetcherImportPath}'
+
+type RouteContext = { params: Promise<Record<string, string | string[]>> }
+
+let _pikku: PikkuNextJSWorkerRPC | undefined
+let _removeAPIPrefix = true
+
+export const removeAPIPrefix = (enable: boolean) => {
+  _removeAPIPrefix = enable
+}
+
+export const pikku = (_options?: any) => {
+  if (!_pikku) {
+    _pikku = new PikkuNextJSWorkerRPC({ fetcher })
+  }
+
+  const dynamicActionRequest = async <
+    Route extends keyof HTTPWiringsMap,
+    Method extends keyof HTTPWiringsMap[Route]
+  >(
+    route: Route,
+    method: Method,
+    data: HTTPWiringHandlerOf<Route, Method>['input'] = null
+  ): Promise<HTTPWiringHandlerOf<Route, Method>['output']> => {
+    return _pikku!.actionRequest(route, method, data as any)
+  }
+
+  const staticActionRequest = async <
+    Route extends keyof HTTPWiringsMap,
+    Method extends keyof HTTPWiringsMap[Route]
+  >(
+    route: Route,
+    method: Method,
+    data: HTTPWiringHandlerOf<Route, Method>['input'] = null
+  ): Promise<HTTPWiringHandlerOf<Route, Method>['output']> => {
+    return _pikku!.staticActionRequest(route, method, data as any)
+  }
+
+  const dynamicPost = <Route extends HTTPWiringsWithMethod<'POST'>>(
+    route: Route,
+    ...args: HTTPWiringHandlerOf<Route, 'POST'>['input'] extends null | undefined
+      ? [data?: HTTPWiringHandlerOf<Route, 'POST'>['input']]
+      : [data: NonNullable<HTTPWiringHandlerOf<Route, 'POST'>['input']>]
+  ): Promise<HTTPWiringHandlerOf<Route, 'POST'>['output']> => {
+    return dynamicActionRequest(route, 'POST', args[0] ?? null)
+  }
+
+  const dynamicGet = <Route extends HTTPWiringsWithMethod<'GET'>>(
+    route: Route,
+    ...args: HTTPWiringHandlerOf<Route, 'GET'>['input'] extends null | undefined
+      ? [data?: HTTPWiringHandlerOf<Route, 'GET'>['input']]
+      : [data: NonNullable<HTTPWiringHandlerOf<Route, 'GET'>['input']>]
+  ): Promise<HTTPWiringHandlerOf<Route, 'GET'>['output']> => {
+    return dynamicActionRequest(route, 'GET', args[0] ?? null)
+  }
+
+  const dynamicPatch = <Route extends HTTPWiringsWithMethod<'PATCH'>>(
+    route: Route,
+    ...args: HTTPWiringHandlerOf<Route, 'PATCH'>['input'] extends null | undefined
+      ? [data?: HTTPWiringHandlerOf<Route, 'PATCH'>['input']]
+      : [data: NonNullable<HTTPWiringHandlerOf<Route, 'PATCH'>['input']>]
+  ): Promise<HTTPWiringHandlerOf<Route, 'PATCH'>['output']> => {
+    return dynamicActionRequest(route, 'PATCH', args[0] ?? null)
+  }
+
+  const dynamicDel = <Route extends HTTPWiringsWithMethod<'DELETE'>>(
+    route: Route,
+    ...args: HTTPWiringHandlerOf<Route, 'DELETE'>['input'] extends null | undefined
+      ? [data?: HTTPWiringHandlerOf<Route, 'DELETE'>['input']]
+      : [data: NonNullable<HTTPWiringHandlerOf<Route, 'DELETE'>['input']>]
+  ): Promise<HTTPWiringHandlerOf<Route, 'DELETE'>['output']> => {
+    return dynamicActionRequest(route, 'DELETE', args[0] ?? null)
+  }
+
+  const staticPost = <Route extends HTTPWiringsWithMethod<'POST'>>(
+    route: Route,
+    ...args: HTTPWiringHandlerOf<Route, 'POST'>['input'] extends null | undefined
+      ? [data?: HTTPWiringHandlerOf<Route, 'POST'>['input']]
+      : [data: NonNullable<HTTPWiringHandlerOf<Route, 'POST'>['input']>]
+  ): Promise<HTTPWiringHandlerOf<Route, 'POST'>['output']> => {
+    return staticActionRequest(route, 'POST', args[0] ?? null)
+  }
+
+  const staticGet = <Route extends HTTPWiringsWithMethod<'GET'>>(
+    route: Route,
+    ...args: HTTPWiringHandlerOf<Route, 'GET'>['input'] extends null | undefined
+      ? [data?: HTTPWiringHandlerOf<Route, 'GET'>['input']]
+      : [data: NonNullable<HTTPWiringHandlerOf<Route, 'GET'>['input']>]
+  ): Promise<HTTPWiringHandlerOf<Route, 'GET'>['output']> => {
+    return staticActionRequest(route, 'GET', args[0] ?? null)
+  }
+
+  // RPC dispatch goes through the underlying actionRequest (route: unknown)
+  // rather than the typed dynamic/static wrappers — '/rpc/:rpcName' isn't
+  // necessarily registered as an HTTPWiringsMap key in projects that haven't
+  // explicitly wired one. Output type is enforced via FlattenedRPCMap.
+  const rpc = async <Name extends keyof FlattenedRPCMap>(
+    rpcName: Name,
+    data: FlattenedRPCMap[Name]['input']
+  ): Promise<FlattenedRPCMap[Name]['output']> => {
+    return _pikku!.actionRequest(
+      '${globalHTTPPrefix}/rpc/:rpcName',
+      'POST',
+      { rpcName, data: data ?? null }
+    ) as Promise<FlattenedRPCMap[Name]['output']>
+  }
+
+  const staticRPC = async <Name extends keyof FlattenedRPCMap>(
+    rpcName: Name,
+    data: FlattenedRPCMap[Name]['input']
+  ): Promise<FlattenedRPCMap[Name]['output']> => {
+    return _pikku!.staticActionRequest(
+      '${globalHTTPPrefix}/rpc/:rpcName',
+      'POST',
+      { rpcName, data: data ?? null }
+    ) as Promise<FlattenedRPCMap[Name]['output']>
+  }
+
+  return {
+    rpc,
+    get: dynamicGet,
+    post: dynamicPost,
+    patch: dynamicPatch,
+    del: dynamicDel,
+    staticGet,
+    staticPost,
+    staticRPC,
+  }
+}
+
+export const pikkuAPIRequest = (
+  req: NextRequest,
+  context: RouteContext
+): Promise<Response> => {
+  if (!_pikku) {
+    _pikku = new PikkuNextJSWorkerRPC({ fetcher })
+  }
+  if (_removeAPIPrefix) {
+    const url = new URL(req.url)
+    url.pathname = url.pathname.replace(/^\\/api/, '') || '/'
+    req = new NextRequest(url.toString(), {
+      method: req.method,
+      headers: req.headers,
+      body: req.body,
+      duplex: 'half',
+    } as any)
+  }
+  return _pikku.apiRequest(req)
+}
+`;
+};

package/dist/src/functions/runtimes/nextjs/serialize-nextjs-http-wrapper.d.ts

@@ -1 +1 @@
-export declare const serializeNextJsHTTPWrapper: (routesMapPath: string, rpcMapPath: string, pikkuFetchImport: string, globalHTTPPrefix?: string) => string;
+export declare const serializeNextJsHTTPWrapper: (routesMapPath: string, rpcMapPath: string, pikkuFetchImport: string, globalHTTPPrefix?: string, defaultServerUrlExpression?: string) => string;

package/dist/src/functions/runtimes/nextjs/serialize-nextjs-http-wrapper.js

@@ -1,4 +1,4 @@
-export const serializeNextJsHTTPWrapper = (routesMapPath, rpcMapPath, pikkuFetchImport, globalHTTPPrefix = '') => {
+export const serializeNextJsHTTPWrapper = (routesMapPath, rpcMapPath, pikkuFetchImport, globalHTTPPrefix = '', defaultServerUrlExpression) => {
     return `'server-only'
   
 /**
@@ -11,6 +11,7 @@ import type { FlattenedRPCMap } from '${rpcMapPath}'
 import { PikkuFetch } from '${pikkuFetchImport}'
 
 let _pikku: PikkuFetch | undefined
+const defaultServerUrl = ${defaultServerUrlExpression ?? 'undefined'}
 
 /**
  * Initializes and returns an instance of PikkuNextJS with helper methods for handling route requests.
@@ -19,7 +20,9 @@ let _pikku: PikkuFetch | undefined
  */
 export const pikku = (options?: CorePikkuFetchOptions) => {
   if (!_pikku) {
-    _pikku = new PikkuFetch(options)
+    _pikku = new PikkuFetch(
+      defaultServerUrl ? { serverUrl: defaultServerUrl, ...options } : options
+    )
   }
 
   const dynamicActionRequest = async <

package/dist/src/functions/runtimes/tanstack-start/pikku-command-tanstack-start.d.ts

@@ -0,0 +1 @@
+export declare const pikkuTanStackStart: import("#pikku").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<void, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;

package/dist/src/functions/runtimes/tanstack-start/pikku-command-tanstack-start.js

@@ -0,0 +1,32 @@
+import { pikkuSessionlessFunc } from '#pikku';
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
+import { writeFileInDir } from '../../../utils/file-writer.js';
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
+import { serializeTanStackStartShim } from './serialize-tanstack-start-shim.js';
+export const pikkuTanStackStart = pikkuSessionlessFunc({
+    func: async ({ logger, config }) => {
+        const startServerFnsFile = config.clientFiles?.startServerFnsFile;
+        const rpcWiringsFile = config.clientFiles?.rpcWiringsFile;
+        const { packageMappings } = config;
+        if (!startServerFnsFile) {
+            logger.debug({
+                message: "Skipping generating TanStack Start shim since startServerFnsFile isn't set in the pikku config.",
+                type: 'skip',
+            });
+            return;
+        }
+        if (!rpcWiringsFile) {
+            logger.warn('Skipping TanStack Start shim: startServerFnsFile is set but rpcWiringsFile is not — the shim imports the PikkuRPC class from rpcWiringsFile.');
+            return;
+        }
+        const rpcWiringsPath = getFileImportRelativePath(startServerFnsFile, rpcWiringsFile, packageMappings);
+        const content = serializeTanStackStartShim(rpcWiringsPath);
+        await writeFileInDir(logger, startServerFnsFile, content);
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Generating TanStack Start shim',
+            commandEnd: 'Generated TanStack Start shim',
+        }),
+    ],
+});

package/dist/src/functions/runtimes/tanstack-start/serialize-tanstack-start-shim.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Serialize the TanStack Start server-function shim.
+ *
+ * The "server function" is a Pikku function; this shim is a typed *caller* over
+ * the generated RPC map (`PikkuRPC`) for use in Start loaders, actions and
+ * components. The API base URL comes from `import.meta.env.VITE_API_URL` and the
+ * shim throws if it is unset — never hardcode a host.
+ *
+ * @param rpcWiringsPath - import path to the file exporting the `PikkuRPC` class
+ */
+export declare const serializeTanStackStartShim: (rpcWiringsPath: string) => string;

package/dist/src/functions/runtimes/tanstack-start/serialize-tanstack-start-shim.js

@@ -0,0 +1,36 @@
+/**
+ * Serialize the TanStack Start server-function shim.
+ *
+ * The "server function" is a Pikku function; this shim is a typed *caller* over
+ * the generated RPC map (`PikkuRPC`) for use in Start loaders, actions and
+ * components. The API base URL comes from `import.meta.env.VITE_API_URL` and the
+ * shim throws if it is unset — never hardcode a host.
+ *
+ * @param rpcWiringsPath - import path to the file exporting the `PikkuRPC` class
+ */
+export const serializeTanStackStartShim = (rpcWiringsPath) => {
+    return `/**
+ * This file was generated by the @pikku/cli
+ *
+ * TanStack Start server-function shim. \`makeApi()\` returns a typed PikkuRPC
+ * caller; use it in loaders/actions/components, e.g.
+ *
+ *   loader: () => makeApi().invoke('listCards', {})
+ *
+ * The API base URL is read from \`import.meta.env.VITE_API_URL\`.
+ */
+import { PikkuRPC } from '${rpcWiringsPath}'
+
+export function makeApi(): PikkuRPC {
+  const serverUrl = import.meta.env.VITE_API_URL
+  if (!serverUrl) {
+    throw new Error(
+      'VITE_API_URL is not set — point it at the Pikku API base URL'
+    )
+  }
+  const rpc = new PikkuRPC()
+  rpc.setServerUrl(serverUrl)
+  return rpc
+}
+`;
+};

package/dist/src/functions/runtimes/websocket/pikku-command-websocket-typed.d.ts

@@ -1 +1 @@
-export declare const pikkuWebSocketTyped: import("#pikku").PikkuFunctionConfig<void, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<void, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<void, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;
+export declare const pikkuWebSocketTyped: import("#pikku").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<void, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;

package/dist/src/functions/wirings/ai-agent/pikku-command-ai-agent-types.d.ts

@@ -1 +1 @@
-export declare const pikkuAIAgentTypes: import("#pikku").PikkuFunctionConfig<void, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<void, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<void, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;
+export declare const pikkuAIAgentTypes: import("#pikku").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<void, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;

package/dist/src/functions/wirings/ai-agent/pikku-command-ai-agent.d.ts

@@ -1 +1 @@
-export declare const pikkuAIAgent: import("#pikku").PikkuFunctionConfig<void, boolean | undefined, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<void, boolean | undefined, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<void, boolean | undefined, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;
+export declare const pikkuAIAgent: import("#pikku").PikkuFunctionConfig<void, boolean | undefined, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, boolean | undefined, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<void, boolean | undefined, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;

package/dist/src/functions/wirings/ai-agent/pikku-command-ai-agent.js

@@ -45,19 +45,10 @@ export const pikkuAIAgent = pikkuSessionlessFunc({
         const importStatement = supportsImportAttributes
             ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
             : `import metaData from '${jsonImportPath}'`;
-        const modelConfigLines = [];
-        if (!addonName &&
-            (config.models || config.agentDefaults || config.agentOverrides)) {
-            modelConfigLines.push(`\npikkuState(null, 'models', 'config', ${JSON.stringify({
-                models: config.models,
-                agentDefaults: config.agentDefaults,
-                agentOverrides: config.agentOverrides,
-            })} as any)`);
-        }
         await writeFileInDir(logger, agentWiringMetaFile, `import { pikkuState } from '@pikku/core/internal'
 import type { AIAgentMeta } from '@pikku/core/ai-agent'
 ${importStatement}
-pikkuState(${addonName ? `'${addonName}'` : 'null'}, 'agent', 'agentsMeta', metaData.agentsMeta as AIAgentMeta)${modelConfigLines.join('')}`);
+pikkuState(${addonName ? `'${addonName}'` : 'null'}, 'agent', 'agentsMeta', metaData.agentsMeta as AIAgentMeta)`);
         await writeFileInDir(logger, agentMapDeclarationFile, serializeAgentMap(logger, agentMapDeclarationFile, packageMappings, functions.typesMap, agents.agentsMeta));
         return true;
     },

package/dist/src/functions/wirings/ai-agent/pikku-command-public-agent.d.ts

@@ -1 +1 @@
-export declare const pikkuPublicAgent: import("#pikku").PikkuFunctionConfig<void, boolean, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<void, boolean, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<void, boolean, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;
+export declare const pikkuPublicAgent: import("#pikku").PikkuFunctionConfig<void, boolean, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, boolean, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<void, boolean, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;

package/dist/src/functions/wirings/ai-agent/serialize-public-agent.js

@@ -1,11 +1,13 @@
 export const serializePublicAgent = (pathToPikkuTypes, requireAuth = true, globalHTTPPrefix = '') => {
     const authFlag = requireAuth ? 'true' : 'false';
-    return `import { pikkuSessionlessFunc, defineHTTPRoutes, wireHTTPRoutes } from '${pathToPikkuTypes}'
+    return `import { MissingServiceError } from '@pikku/core/errors'
+import { pikkuSessionlessFunc, defineHTTPRoutes, wireHTTPRoutes } from '${pathToPikkuTypes}'
 
 export const agentCaller = pikkuSessionlessFunc<
   { agentName: string; message: string; threadId: string; resourceId: string },
   unknown
 >({
+  tags: ['pikku'],
   auth: ${authFlag},
   func: async (_services, data, { rpc }) => {
     return await rpc.agent.run(data.agentName as any, {
@@ -20,6 +22,7 @@ export const agentStreamCaller = pikkuSessionlessFunc<
   { agentName: string; message: string; threadId: string; resourceId: string },
   void
 >({
+  tags: ['pikku'],
   auth: ${authFlag},
   func: async (_services, data, { rpc }) => {
     await rpc.agent.stream(data.agentName as any, {
@@ -34,6 +37,7 @@ export const agentApproveCaller = pikkuSessionlessFunc<
   { agentName: string; runId: string; approvals: { toolCallId: string; approved: boolean }[] },
   unknown
 >({
+  tags: ['pikku'],
   auth: ${authFlag},
   func: async (_services, { runId, approvals, agentName }, { rpc }) => {
     return await rpc.agent.approve(runId, approvals, agentName)
@@ -44,6 +48,7 @@ export const agentResumeCaller = pikkuSessionlessFunc<
   { agentName: string; runId: string; toolCallId: string; approved: boolean },
   void
 >({
+  tags: ['pikku'],
   auth: ${authFlag},
   func: async (_services, data, { rpc }) => {
     await rpc.agent.resume(data.runId, {
@@ -53,6 +58,76 @@ export const agentResumeCaller = pikkuSessionlessFunc<
   },
 })
 
+export const getAgentThreads = pikkuSessionlessFunc<
+  { agentName?: string; resourceId?: string; limit?: number; offset?: number },
+  any[]
+>({
+  tags: ['pikku', 'pikku:agent'],
+  title: 'Get Agent Threads',
+  description:
+    'Returns a list of AI agent threads from storage. Accepts optional filters: agentName, resourceId, limit, and offset for pagination.',
+  expose: true,
+  auth: ${authFlag},
+  func: async ({ agentRunService }, input) => {
+    if (!agentRunService) throw new MissingServiceError('agentRunService is not available')
+    return await agentRunService.listThreads({
+      agentName: input?.agentName,
+      resourceId: input?.resourceId,
+      limit: input?.limit,
+      offset: input?.offset,
+    })
+  },
+})
+
+export const getAgentThreadMessages = pikkuSessionlessFunc<
+  { threadId: string; resourceId?: string },
+  any[]
+>({
+  tags: ['pikku', 'pikku:agent'],
+  title: 'Get Agent Thread Messages',
+  description:
+    'Returns all messages for a given AI agent thread, ordered by creation time.',
+  expose: true,
+  auth: ${authFlag},
+  func: async ({ agentRunService }, input) => {
+    if (!agentRunService) throw new MissingServiceError('agentRunService is not available')
+    return await agentRunService.getThreadMessages(input.threadId)
+  },
+})
+
+export const getAgentThreadRuns = pikkuSessionlessFunc<
+  { threadId: string; resourceId?: string },
+  any[]
+>({
+  tags: ['pikku', 'pikku:agent'],
+  title: 'Get Agent Thread Runs',
+  description:
+    'Returns the run history for a given AI agent thread, ordered by creation time.',
+  expose: true,
+  auth: ${authFlag},
+  func: async ({ agentRunService }, input) => {
+    if (!agentRunService) throw new MissingServiceError('agentRunService is not available')
+    return await agentRunService.getThreadRuns(input.threadId)
+  },
+})
+
+export const deleteAgentThread = pikkuSessionlessFunc<
+  { threadId: string; resourceId?: string },
+  { deleted: boolean }
+>({
+  tags: ['pikku', 'pikku:agent'],
+  title: 'Delete Agent Thread',
+  description:
+    'Deletes an AI agent thread and all of its persisted state.',
+  expose: true,
+  auth: ${authFlag},
+  func: async ({ agentRunService }, input) => {
+    if (!agentRunService) throw new MissingServiceError('agentRunService is not available')
+    const deleted = await agentRunService.deleteThread(input.threadId)
+    return { deleted }
+  },
+})
+
 export const agentRoutes = defineHTTPRoutes({
   auth: ${authFlag},
   tags: ['pikku:public'],

package/dist/src/functions/wirings/channels/pikku-channels.d.ts

@@ -1 +1 @@
-export declare const pikkuChannels: import("#pikku").PikkuFunctionConfig<void, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<void, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<void, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;
+export declare const pikkuChannels: import("#pikku").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<void, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;

package/dist/src/functions/wirings/channels/pikku-command-channel-types.d.ts

@@ -1 +1 @@
-export declare const pikkuChannelTypes: import("#pikku").PikkuFunctionConfig<void, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<void, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<void, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;
+export declare const pikkuChannelTypes: import("#pikku").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<void, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;

package/dist/src/functions/wirings/channels/pikku-command-channels-map.d.ts

@@ -1 +1 @@
-export declare const pikkuChannelsMap: import("#pikku").PikkuFunctionConfig<void, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<void, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<void, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;
+export declare const pikkuChannelsMap: import("#pikku").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<void, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;

package/dist/src/functions/wirings/channels/pikku-command-channels.d.ts

@@ -1 +1 @@
-export declare const pikkuCommandChannels: import("#pikku").PikkuFunctionConfig<void, boolean | undefined, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<void, boolean | undefined, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<void, boolean | undefined, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;
+export declare const pikkuCommandChannels: import("#pikku").PikkuFunctionConfig<void, boolean | undefined, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, boolean | undefined, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<void, boolean | undefined, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;

package/dist/src/functions/wirings/cli/pikku-command-cli-entry.d.ts

@@ -1 +1 @@
-export declare const pikkuCLIEntry: import("#pikku").PikkuFunctionConfig<void, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<void, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<void, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;
+export declare const pikkuCLIEntry: import("#pikku").PikkuFunctionConfig<void, boolean, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, boolean, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<void, boolean, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;