@percepta/create 3.4.2 → 3.4.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@percepta/create",
-  "version": "3.4.2",
+  "version": "3.4.3",
   "description": "Scaffold a new Mosaic package",
   "keywords": [
     "cli",

package/templates/webapp/AGENTS.md

@@ -158,7 +158,7 @@ logger.info({ safe: { requestId }, unsafe: { email } }, "User action completed")
 logger.error({ safe: { documentId } }, "Processing failed", error);
 ```
 
-The app's logger is initialized in `src/services/logger/AppLogger.ts` using `createLogFactory()` and `createTracerFactory()` from this package. It uses `AsyncLocalStorage` for automatic request context propagation.
+The app's logger is initialized in `src/services/logger/AppLogger.ts` using `createLoggerRuntime()` from this package. It uses `AsyncLocalStorage` for automatic request context propagation.
 
 ### @percepta/utils — Shared Utilities
 

package/templates/webapp/agent-skills/inngest.md

@@ -43,14 +43,14 @@ schemas validate `event.data`, so do not wrap payload schemas in another
 
 ### 1. Create a function collection
 
-Group related functions into a collection class that implements `InngestFunctionCollection`:
+Group related functions into a collection class that implements `PerceptaInngestFunctionCollection`:
 
 ```typescript
+import { type PerceptaInngestFunctionCollection } from "@percepta/inngest";
 import { type InngestFunction } from "inngest";
-import { type InngestFunctionCollection } from "../InngestFunctionCollection";
 import { InngestService } from "../InngestService";
 
-export class DocumentFunctions implements InngestFunctionCollection {
+export class DocumentFunctions implements PerceptaInngestFunctionCollection {
   private inngestService = InngestService.create();
 
   public get functions(): InngestFunction.Like[] {
@@ -85,9 +85,9 @@ export class DocumentFunctions implements InngestFunctionCollection {
 Add your collection to the `functionCollections` array in the Inngest serve endpoint:
 
 ```typescript
-const functionCollections: InngestFunctionCollection[] = compact([
+const functionCollections: PerceptaInngestFunctionCollection[] = [
   new DocumentFunctions(),
-]);
+];
 ```
 
 ## Sending Events

package/templates/webapp/agent-skills/langfuse.md

@@ -21,14 +21,14 @@ Langfuse is an open-source LLM observability platform. It captures traces, spans
 The template uses Next.js's instrumentation hook (called on server startup) to bootstrap OTEL with both the environment collector and optional Langfuse:
 
 ```typescript
-import { LangfuseSpanProcessor } from "@langfuse/otel";
-import { NodeSDK, tracing } from "@opentelemetry/sdk-node";
 import { getNodeAutoInstrumentations } from "@opentelemetry/auto-instrumentations-node";
+import { NodeSDK, tracing } from "@opentelemetry/sdk-node";
+import { createLangfuseSpanProcessor } from "@percepta/ai";
 
 const sdk = new NodeSDK({
   spanProcessors: [
     new tracing.BatchSpanProcessor(otlpTraceExporter),
-    new LangfuseSpanProcessor({ baseUrl, publicKey, secretKey }),
+    createLangfuseSpanProcessor(env, logger),
   ],
   instrumentations: [getNodeAutoInstrumentations()],
 });
@@ -37,7 +37,7 @@ sdk.start();
 
 - `getNodeAutoInstrumentations()` automatically instruments HTTP calls, database queries, and other standard Node.js operations.
 - The OTLP span processor forwards general server traces to the environment collector.
-- `LangfuseSpanProcessor` forwards only AI SDK spans to Langfuse when all `LANGFUSE_*` variables are set. General HTTP, DB, and server spans stay in the OTEL/LGTM pipeline and are not sent to Langfuse by default.
+- The shared Langfuse span processor forwards only AI SDK spans to Langfuse when all `LANGFUSE_*` variables are set. General HTTP, DB, and server spans stay in the OTEL/LGTM pipeline and are not sent to Langfuse by default.
 
 **You do not need to manually instrument LLM calls.** Use `LLMService` from `src/services/llm/LLMService.ts`; it calls the Vercel AI SDK with telemetry enabled and provider/model metadata attached.
 

package/templates/webapp/agent-skills/llm.md

@@ -30,7 +30,7 @@ const stream = LLMService.create().streamText({
 
 ## Providers
 
-`LlmProviderService` chooses a provider at call time:
+The shared `@percepta/ai` provider helper chooses a provider at call time:
 
 1. `LLM_PROVIDER`, when explicitly set.
 2. Anthropic when `ANTHROPIC_API_KEY` is available.

package/templates/webapp/package.json.template

@@ -33,8 +33,6 @@
     "test:watch": "vitest"
   },
   "dependencies": {
-    "@ai-sdk/anthropic": "^2.0.23",
-    "@ai-sdk/openai": "^2.0.23",
     "@aws-sdk/client-s3": "^3.888.0",
     "@aws-sdk/client-secrets-manager": "^3.914.0",
     "@aws-sdk/client-sts": "^3.913.0",
@@ -48,9 +46,6 @@
     "@grafana/faro-web-sdk": "^1.14.0",
     "@grafana/faro-web-tracing": "^1.14.0",
     "@hookform/resolvers": "^5.2.2",
-    "@inngest/middleware-validation": "^0.0.5",
-    "@langfuse/otel": "^4.0.0",
-    "@langfuse/tracing": "^4.0.0",
     "@mantine/hooks": "^8.3.1",
     "@next/env": "^15.3.5",
     "@opentelemetry/api": "^1.9.0",
@@ -58,10 +53,12 @@
     "@opentelemetry/exporter-trace-otlp-proto": "^0.203.0",
     "@opentelemetry/sdk-node": "^0.203.0",
     "@__REPO_NAME__/auth": "workspace:*",
-    "@percepta/access-control": "0.6.1",
+    "@percepta/access-control": "0.7.0",
+    "@percepta/ai": "0.1.0",
     "@percepta/design": "0.3.2",
-    "@percepta/logger": "0.0.6",
-    "@percepta/next-utils": "0.1.0",
+    "@percepta/inngest": "0.1.0",
+    "@percepta/logger": "0.1.0",
+    "@percepta/next-utils": "0.2.0",
     "@percepta/utils": "0.1.10",
     "@radix-ui/react-slot": "^1.2.3",
     "@tanstack/react-query": "^5.81.5",
@@ -69,7 +66,6 @@
     "@trpc/client": "^11.4.3",
     "@trpc/server": "^11.4.3",
     "@trpc/tanstack-react-query": "^11.4.3",
-    "ai": "^5.0.24",
     "better-auth": "^1.6.4",
     "clsx": "^2.1.1",
     "date-fns": "^4.1.0",
@@ -80,15 +76,12 @@
     "import-in-the-middle": "^1.14.2",
     "inngest": "^3.44.3",
     "keyed-type-union": "^0.1.0",
-    "langfuse": "^3.38.6",
     "lodash-es": "^4.17.21",
     "lucide-react": "^0.542.0",
     "mime-types": "^3.0.1",
     "next": "^15.3.5",
     "numeral": "^2.0.6",
     "pg": "^8.16.3",
-    "pino": "^10.1.0",
-    "pino-pretty": "^13.1.3",
     "pluralize": "^8.0.0",
     "react": "^19.0.0",
     "react-dom": "^19.0.0",

package/templates/webapp/src/app/api/inngest/route.ts

@@ -1,31 +1,21 @@
-import { serve } from "inngest/next";
-import { compact } from "lodash-es";
-import { type InngestFunctionCollection } from "../../../services/inngest/InngestFunctionCollection";
+import {
+  createPerceptaInngestNextRouteHandlers,
+  type PerceptaInngestFunctionCollection,
+} from "@percepta/inngest";
 import { InngestService } from "../../../services/inngest/InngestService";
 
 export const dynamic = "force-dynamic";
 
-const functionCollections: InngestFunctionCollection[] = compact([]);
+const functionCollections: PerceptaInngestFunctionCollection[] = [];
 
 // InngestService.create() reads env vars and throws if INNGEST_BASE_URL is
 // unset. Defer initialization until request time so `next build` can compile
 // this route without those vars present.
-type Handlers = ReturnType<typeof serve>;
+const inngestHandlers = createPerceptaInngestNextRouteHandlers({
+  getService: () => InngestService.create(),
+  getFunctions: () => functionCollections.flatMap(({ functions }) => functions),
+});
 
-let cachedHandlers: Handlers | undefined;
-
-function getHandlers(): Handlers {
-  if (cachedHandlers == null) {
-    const inngestService = InngestService.create();
-    cachedHandlers = serve({
-      client: inngestService.client,
-      functions: functionCollections.flatMap(({ functions }) => functions),
-      signingKey: inngestService.signingKey,
-    });
-  }
-  return cachedHandlers;
-}
-
-export const GET: Handlers["GET"] = (...args) => getHandlers().GET(...args);
-export const POST: Handlers["POST"] = (...args) => getHandlers().POST(...args);
-export const PUT: Handlers["PUT"] = (...args) => getHandlers().PUT(...args);
+export const GET = inngestHandlers.GET;
+export const POST = inngestHandlers.POST;
+export const PUT = inngestHandlers.PUT;

package/templates/webapp/src/instrumentation.ts

@@ -1,52 +1,12 @@
-import { LangfuseSpanProcessor } from "@langfuse/otel";
 import { getNodeAutoInstrumentations } from "@opentelemetry/auto-instrumentations-node";
 import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-proto";
 import { NodeSDK, tracing } from "@opentelemetry/sdk-node";
+import { createLangfuseSpanProcessor } from "@percepta/ai";
 import { compact } from "lodash-es";
 import { getEnvConfig } from "./config/getEnvConfig";
 import { getLogger } from "./services/logger/AppLogger";
 
 type SpanProcessor = tracing.SpanProcessor;
-type ReadableSpan = Parameters<SpanProcessor["onEnd"]>[0];
-type OnStartArgs = Parameters<SpanProcessor["onStart"]>;
-
-class FilteringSpanProcessor implements SpanProcessor {
-  public constructor(
-    private delegate: SpanProcessor,
-    private shouldExport: (span: ReadableSpan) => boolean,
-  ) {}
-
-  public forceFlush(): Promise<void> {
-    return this.delegate.forceFlush();
-  }
-
-  public onStart(...args: OnStartArgs): void {
-    this.delegate.onStart(...args);
-  }
-
-  public onEnd(span: ReadableSpan): void {
-    if (this.shouldExport(span)) {
-      this.delegate.onEnd(span);
-    }
-  }
-
-  public shutdown(): Promise<void> {
-    return this.delegate.shutdown();
-  }
-}
-
-function isAiSdkSpan(span: ReadableSpan): boolean {
-  const operationId = span.attributes["ai.operationId"];
-  if (typeof operationId === "string" && operationId.startsWith("ai.")) {
-    return true;
-  }
-
-  if (span.name.startsWith("ai.")) {
-    return true;
-  }
-
-  return Object.keys(span.attributes).some((key) => key.startsWith("gen_ai."));
-}
 
 function getOtlpTracesEndpoint(): string | undefined {
   const {
@@ -90,28 +50,7 @@ function getOtlpSpanProcessor(): tracing.BatchSpanProcessor | undefined {
 }
 
 function getLangfuseSpanProcessor(): SpanProcessor | undefined {
-  const {
-    LANGFUSE_BASE_URL: baseUrl,
-    LANGFUSE_PUBLIC_KEY: publicKey,
-    LANGFUSE_SECRET_KEY: secretKey,
-  } = getEnvConfig();
-  if (!baseUrl || !publicKey || !secretKey) {
-    getLogger().debug(
-      undefined,
-      "Langfuse environment is incomplete. Skipping Langfuse OpenTelemetry.",
-    );
-    return undefined;
-  }
-
-  getLogger().debug(undefined, "Registering Langfuse OpenTelemetry.");
-  return new FilteringSpanProcessor(
-    new LangfuseSpanProcessor({
-      baseUrl,
-      publicKey,
-      secretKey,
-    }),
-    isAiSdkSpan,
-  );
+  return createLangfuseSpanProcessor(getEnvConfig(), getLogger());
 }
 
 const spanProcessors: tracing.SpanProcessor[] = compact([

package/templates/webapp/src/server/trpc.ts

@@ -1,8 +1,5 @@
-import type { PermissionClient, SubjectRef } from "@percepta/access-control";
-import {
-  createRequireApplicationAccess,
-  createRequirePermission,
-} from "@percepta/access-control/trpc";
+import type { SubjectRef } from "@percepta/access-control";
+import { createAppAccessControlMiddlewares } from "@percepta/access-control/trpc";
 import { TRPCError, initTRPC } from "@trpc/server";
 import superjson from "superjson";
 import { accessManifest } from "../access/access.manifest";
@@ -25,12 +22,6 @@ export interface ProtectedContext extends Context {
   session: BetterAuthSession;
 }
 
-const lazyPermissionClient = {
-  can(check) {
-    return getAccessControl().permissions.can(check);
-  },
-} satisfies Pick<PermissionClient, "can">;
-
 function getCurrentSubject(ctx: Context): SubjectRef | null {
   const userId = ctx.session?.user.id;
   return userId == null ? null : toUserSubject(userId);
@@ -76,17 +67,14 @@ const requireAuthenticatedUser = procedure.use(
   },
 );
 
-const requireApplicationAccess =
-  createRequireApplicationAccess<ProtectedContext>({
-    accessControl: lazyPermissionClient,
+const { requireApplicationAccess, requirePermission } =
+  createAppAccessControlMiddlewares<ProtectedContext>({
+    getAccessControl,
     getSubject: getCurrentSubject,
     manifest: accessManifest,
   });
 
-export const requirePermission = createRequirePermission<ProtectedContext>({
-  accessControl: lazyPermissionClient,
-  getSubject: getCurrentSubject,
-});
+export { requirePermission };
 
 export const protectedProcedure = requireAuthenticatedUser;
 

package/templates/webapp/src/services/AuthContextService.ts

@@ -1,63 +1,11 @@
-import { trace } from "@opentelemetry/api";
-import { TRPCError } from "@trpc/server";
+import {
+  createAuthContextServiceFactory,
+  type AuthContextService as PerceptaAuthContextService,
+} from "@percepta/next-utils";
 import type { BetterAuthSession } from "../lib/auth";
 
 export type AuthSession = BetterAuthSession;
 
-export class AuthContextService {
-  private static SINGLETON: AuthContextService | undefined;
-  public static create(): AuthContextService {
-    if (AuthContextService.SINGLETON == null) {
-      AuthContextService.SINGLETON = new AuthContextService();
-    }
-
-    return AuthContextService.SINGLETON;
-  }
-
-  private authAsyncLocalStorage = new AsyncLocalStorage<LocalStorage>();
-
-  private constructor() {}
-
-  public withSession<TReturn>(
-    session: AuthSession,
-    callback: () => TReturn,
-  ): TReturn {
-    // Set user email on the active OpenTelemetry span
-    const activeSpan = trace.getActiveSpan();
-    if (
-      activeSpan != null &&
-      session.user.email != null &&
-      session.user.id != null
-    ) {
-      activeSpan.setAttribute("user.email", session.user.email);
-      activeSpan.setAttribute("user.id", session.user.id);
-    }
-
-    return this.authAsyncLocalStorage.run<TReturn>({ session }, () =>
-      callback(),
-    );
-  }
-
-  public getSession(): AuthSession | undefined {
-    const context = this.authAsyncLocalStorage.getStore();
-    if (context == null) {
-      return undefined;
-    }
-
-    const { session } = context;
-    return session;
-  }
-
-  public getSessionOrThrow(): AuthSession {
-    const session = this.getSession();
-    if (session == null) {
-      throw new TRPCError({ code: "UNAUTHORIZED" });
-    }
-
-    return session;
-  }
-}
-
-interface LocalStorage {
-  session: AuthSession;
-}
+export const AuthContextService =
+  createAuthContextServiceFactory<AuthSession>();
+export type AuthContextService = PerceptaAuthContextService<AuthSession>;

package/templates/webapp/src/services/inngest/InngestService.ts

@@ -1,5 +1,9 @@
-import { validationMiddleware } from "@inngest/middleware-validation";
-import { EventSchemas, Inngest } from "inngest";
+import {
+  createPerceptaInngestServiceFactory,
+  type PerceptaInngest,
+  type PerceptaInngestService,
+} from "@percepta/inngest";
+import { EventSchemas } from "inngest";
 import { getEnvConfig } from "../../config/getEnvConfig";
 import { AppEvents } from "./events/AppEvents";
 
@@ -8,64 +12,12 @@ export interface PollOpts {
   delayMs: number;
 }
 
-export interface AppInngest extends AppInngestInternal {
-  // Externally, we should never call createFunction on the client interface.
-  createFunction: never;
-}
-type AppInngestInternal = Inngest<{
-  id: string;
-  schemas: typeof EVENT_SCHEMAS;
-}>;
-
-export class InngestService {
-  private static SINGLETON: InngestService | undefined;
-  public static create(): InngestService {
-    if (InngestService.SINGLETON == null) {
-      InngestService.SINGLETON = new InngestService();
-    }
-    return InngestService.SINGLETON;
-  }
-
-  private _signingKey: string | undefined;
-  private inngest: AppInngestInternal;
-
-  private constructor() {
-    const {
-      INNGEST_BASE_URL: baseUrl,
-      INNGEST_SIGNING_KEY: signingKey,
-      INNGEST_EVENT_KEY: eventKey,
-    } = getEnvConfig();
-
-    if (baseUrl == null) {
-      throw new Error("INNGEST_BASE_URL is not set.");
-    }
-
-    this._signingKey = signingKey;
-    this.inngest = new Inngest({
-      id: "__APP_NAME__",
-      eventKey,
-      baseUrl,
-      schemas: EVENT_SCHEMAS,
-      middleware: [validationMiddleware()],
-    });
-  }
-
-  public get client(): AppInngest {
-    return this.inngest as never;
-  }
-
-  public get signingKey(): string | undefined {
-    return this._signingKey;
-  }
-
-  public createFunction: Inngest.CreateFunction<AppInngest> = (
-    options,
-    trigger,
-    handler,
-  ) => {
-    // TODO: Add context plumbing here.
-    return this.inngest.createFunction(options, trigger, handler) as never;
-  };
-}
-
 const EVENT_SCHEMAS = new EventSchemas().fromSchema(AppEvents);
+
+export type AppInngest = PerceptaInngest<typeof EVENT_SCHEMAS>;
+export const InngestService = createPerceptaInngestServiceFactory({
+  appId: "__APP_NAME__",
+  getEnv: getEnvConfig,
+  schemas: EVENT_SCHEMAS,
+});
+export type InngestService = PerceptaInngestService<typeof EVENT_SCHEMAS>;

package/templates/webapp/src/services/langfuse/LangfuseService.ts

@@ -1,80 +1,12 @@
-import { Langfuse } from "langfuse";
+import {
+  createPerceptaLangfuseServiceFactory,
+  type PerceptaLangfuseService,
+} from "@percepta/ai";
 import { getEnvConfig } from "../../config/getEnvConfig";
 import { getLogger } from "../logger/AppLogger";
 
-export class LangfuseService {
-  private static SINGLETON: LangfuseService | undefined;
-
-  public static create(): LangfuseService {
-    if (LangfuseService.SINGLETON == null) {
-      LangfuseService.SINGLETON = new LangfuseService();
-    }
-    return LangfuseService.SINGLETON;
-  }
-
-  private readonly client: Langfuse | undefined;
-
-  private constructor() {
-    const config = getEnvConfig();
-    const baseUrl = config.LANGFUSE_BASE_URL;
-    const publicKey = config.LANGFUSE_PUBLIC_KEY;
-    const secretKey = config.LANGFUSE_SECRET_KEY;
-
-    if (baseUrl && publicKey && secretKey) {
-      this.client = new Langfuse({
-        baseUrl,
-        publicKey,
-        secretKey,
-      });
-    }
-  }
-
-  /**
-   * Check if Langfuse is configured.
-   */
-  public isConfigured(): boolean {
-    return this.client != null;
-  }
-
-  /**
-   * Update a Langfuse trace with metadata.
-   * Uses trace.update() which merges with existing metadata.
-   *
-   * @param traceId - The trace ID (same as documentPipelineRuns.id)
-   * @param metadata - The metadata to save (must be JSON-serializable)
-   */
-  public async updateTraceMetadata<T extends object>(
-    traceId: string,
-    metadata: T,
-  ): Promise<void> {
-    if (!this.isConfigured()) {
-      getLogger().warn(
-        { safe: { traceId } },
-        "[LangfuseService] Langfuse not configured, skipping trace update",
-      );
-      return;
-    }
-
-    // Capture client after isConfigured() guard for type narrowing
-    const client = this.client!;
-
-    try {
-      // Attach to existing trace by ID and update metadata
-      const trace = client.trace({ id: traceId });
-      trace.update({ metadata });
-
-      // Flush to ensure the update is sent
-      await client.flushAsync();
-
-      getLogger().info(
-        { safe: { traceId } },
-        "[LangfuseService] Updated trace with metadata",
-      );
-    } catch (error) {
-      getLogger().error(
-        { safe: { traceId }, unsafe: { error: String(error) } },
-        "[LangfuseService] Failed to update trace metadata",
-      );
-    }
-  }
-}
+export const LangfuseService = createPerceptaLangfuseServiceFactory({
+  getConfig: getEnvConfig,
+  getLogger,
+});
+export type LangfuseService = PerceptaLangfuseService;

package/templates/webapp/src/services/llm/LLMService.ts

@@ -1,88 +1,10 @@
-import { generateText, streamText } from "ai";
-import { type LlmProviderName, LlmProviderService } from "./LlmProviderService";
-
-type GenerateTextOptions = Omit<Parameters<typeof generateText>[0], "model"> & {
-  modelId?: string;
-  provider?: LlmProviderName;
-  telemetryFunctionId?: string;
-};
-
-type StreamTextOptions = Omit<Parameters<typeof streamText>[0], "model"> & {
-  modelId?: string;
-  provider?: LlmProviderName;
-  telemetryFunctionId?: string;
-};
-
-export class LLMService {
-  private static SINGLETON: LLMService | undefined;
-
-  public static create(): LLMService {
-    if (LLMService.SINGLETON == null) {
-      LLMService.SINGLETON = new LLMService(LlmProviderService.create());
-    }
-
-    return LLMService.SINGLETON;
-  }
-
-  private constructor(private llmProviderService: LlmProviderService) {}
-
-  public generateText(
-    options: GenerateTextOptions,
-  ): ReturnType<typeof generateText> {
-    const { modelId, provider, telemetryFunctionId, ...generateOptions } =
-      options;
-    const selection = this.llmProviderService.getLanguageModel({
-      modelId,
-      provider,
-    });
-
-    const aiOptions = {
-      ...generateOptions,
-      model: selection.model,
-      experimental_telemetry: {
-        ...generateOptions.experimental_telemetry,
-        isEnabled: generateOptions.experimental_telemetry?.isEnabled ?? true,
-        functionId:
-          telemetryFunctionId ??
-          generateOptions.experimental_telemetry?.functionId ??
-          "llm.generateText",
-        metadata: {
-          ...generateOptions.experimental_telemetry?.metadata,
-          llmProvider: selection.provider,
-          llmModel: selection.modelId,
-        },
-      },
-    } as Parameters<typeof generateText>[0];
-
-    return generateText(aiOptions);
-  }
-
-  public streamText(options: StreamTextOptions): ReturnType<typeof streamText> {
-    const { modelId, provider, telemetryFunctionId, ...streamOptions } =
-      options;
-    const selection = this.llmProviderService.getLanguageModel({
-      modelId,
-      provider,
-    });
-
-    const aiOptions = {
-      ...streamOptions,
-      model: selection.model,
-      experimental_telemetry: {
-        ...streamOptions.experimental_telemetry,
-        isEnabled: streamOptions.experimental_telemetry?.isEnabled ?? true,
-        functionId:
-          telemetryFunctionId ??
-          streamOptions.experimental_telemetry?.functionId ??
-          "llm.streamText",
-        metadata: {
-          ...streamOptions.experimental_telemetry?.metadata,
-          llmProvider: selection.provider,
-          llmModel: selection.modelId,
-        },
-      },
-    } as Parameters<typeof streamText>[0];
-
-    return streamText(aiOptions);
-  }
-}
+import {
+  createPerceptaLlmServiceFactory,
+  type PerceptaLlmService,
+} from "@percepta/ai";
+import { getEnvConfig } from "../../config/getEnvConfig";
+
+export const LLMService = createPerceptaLlmServiceFactory({
+  getConfig: getEnvConfig,
+});
+export type LLMService = PerceptaLlmService;

package/templates/webapp/src/services/logger/AppLogger.ts

@@ -1,11 +1,4 @@
-import {
-  type MosaicLogger,
-  createLogFactory,
-  createTracerFactory,
-} from "@percepta/logger";
-import { assertNever } from "@percepta/utils";
-import pino, { type Logger } from "pino";
-import pretty from "pino-pretty";
+import { createLoggerRuntime } from "@percepta/logger";
 import { getEnvConfig } from "../../config/getEnvConfig";
 
 /**
@@ -19,43 +12,5 @@ import { getEnvConfig } from "../../config/getEnvConfig";
  * All logs automatically include request context (reqId, method, path, host)
  * when called within a request scope established by withLogContext().
  */
-export const { getLogger, withLogContext } = createLogFactory(
-  createBasePinoInstance(),
-  () => new AsyncLocalStorage<MosaicLogger>(),
-);
-
-/**
- * Tracer for request context propagation.
- * Uses AsyncLocalStorage to pass trace IDs through async boundaries.
- */
-export const { getTracer, withTracer } = createTracerFactory(
-  () => new AsyncLocalStorage(),
-);
-
-// TODO(@dzhao): Generalize this and move to createPinoInstance.ts.
-function createBasePinoInstance(): Logger {
-  const { NODE_ENV: nodeEnv, LOG_LEVEL: level } = getEnvConfig();
-
-  switch (nodeEnv) {
-    case "production":
-      return pino({
-        level,
-        formatters: {
-          level: (label) => ({ level: label }),
-        },
-      });
-    case "development":
-    case "test":
-      // Development: use pino-pretty synchronously (avoids worker thread issues with Next.js/Turbopack)
-      return pino(
-        { level },
-        pretty({
-          colorize: true,
-          translateTime: "SYS:standard",
-          ignore: "pid,hostname",
-        }),
-      );
-    default:
-      return assertNever(nodeEnv);
-  }
-}
+export const { getLogger, getTracer, withLogContext, withTracer } =
+  createLoggerRuntime({ env: getEnvConfig() });

package/templates/webapp/src/utils/syncInngestApp.ts

@@ -1,62 +1,10 @@
+import { syncPerceptaInngestApp } from "@percepta/inngest";
 import { getEnvConfig } from "../config/getEnvConfig";
 import { getLogger } from "../services/logger/AppLogger";
 
 export async function syncInngestApp(): Promise<void> {
-  const {
-    SKIP_INNGEST_SYNC: skipSync,
-    INNGEST_BASE_URL: inngestServerUrl,
-    APP_BASE_URL: appBaseUrl,
-    INNGEST_APP_URL,
-  } = getEnvConfig();
-
-  // Cascade: explicit INNGEST_APP_URL > derived from APP_BASE_URL > localhost fallback
-  const appUrl =
-    INNGEST_APP_URL ??
-    (appBaseUrl
-      ? `${appBaseUrl}/api/inngest`
-      : "http://localhost:3000/api/inngest");
-
-  if (skipSync) {
-    getLogger().info(undefined, "SKIP_INNGEST_SYNC=true, skipping auto-sync");
-    return;
-  }
-
-  // INNGEST_BASE_URL is required
-  if (!inngestServerUrl) {
-    getLogger().error(
-      undefined,
-      "INNGEST_BASE_URL environment variable is not set, skipping sync",
-    );
-    return;
-  }
-
-  const gqlEndpoint = `${inngestServerUrl}/v0/gql`;
-
-  getLogger().info(
-    { safe: { gqlEndpoint, appUrl } },
-    "Syncing with Inngest Server",
-  );
-
-  const payload = {
-    operationName: "CreateApp",
-    query:
-      "mutation CreateApp($input: CreateAppInput!) {\n createApp(input: $input) {\n url\n }\n}\n",
-    variables: {
-      input: {
-        url: appUrl,
-      },
-    },
-  };
-
-  const response = await fetch(gqlEndpoint, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-    },
-    body: JSON.stringify(payload),
+  await syncPerceptaInngestApp({
+    getEnv: getEnvConfig,
+    logger: getLogger(),
   });
-
-  if (response.ok) {
-    getLogger().info(undefined, "Successfully synced with Inngest Server");
-  }
 }

package/templates/webapp/src/services/inngest/InngestFunctionCollection.ts

@@ -1,5 +0,0 @@
-import { type InngestFunction } from "inngest";
-
-export interface InngestFunctionCollection {
-  functions: InngestFunction.Like[];
-}

package/templates/webapp/src/services/llm/LlmProviderService.ts

@@ -1,85 +0,0 @@
-import { createAnthropic } from "@ai-sdk/anthropic";
-import { createOpenAI } from "@ai-sdk/openai";
-import { type LanguageModel } from "ai";
-import { getEnvConfig } from "../../config/getEnvConfig";
-
-export type LlmProviderName = "anthropic" | "openai";
-
-export interface LanguageModelSelection {
-  model: LanguageModel;
-  modelId: string;
-  provider: LlmProviderName;
-}
-
-interface GetLanguageModelOptions {
-  modelId?: string;
-  provider?: LlmProviderName;
-}
-
-const DEFAULT_ANTHROPIC_MODEL = "claude-sonnet-4-5-20250929";
-const DEFAULT_OPENAI_MODEL = "gpt-4.1";
-
-export class LlmProviderService {
-  private static SINGLETON: LlmProviderService | undefined;
-
-  public static create(): LlmProviderService {
-    if (LlmProviderService.SINGLETON == null) {
-      LlmProviderService.SINGLETON = new LlmProviderService();
-    }
-
-    return LlmProviderService.SINGLETON;
-  }
-
-  private constructor() {}
-
-  public getLanguageModel(
-    options: GetLanguageModelOptions = {},
-  ): LanguageModelSelection {
-    const config = getEnvConfig();
-    const provider =
-      options.provider ??
-      config.LLM_PROVIDER ??
-      (config.ANTHROPIC_API_KEY ? "anthropic" : undefined) ??
-      (config.OPENAI_API_KEY ? "openai" : undefined);
-
-    if (provider === "anthropic") {
-      if (!config.ANTHROPIC_API_KEY) {
-        throw new Error(
-          "LLM_PROVIDER=anthropic but ANTHROPIC_API_KEY is not configured.",
-        );
-      }
-
-      const modelId =
-        options.modelId ?? config.LLM_MODEL ?? DEFAULT_ANTHROPIC_MODEL;
-      return {
-        provider,
-        modelId,
-        model: createAnthropic({
-          apiKey: config.ANTHROPIC_API_KEY,
-        }).languageModel(modelId),
-      };
-    }
-
-    if (provider === "openai") {
-      if (!config.OPENAI_API_KEY) {
-        throw new Error(
-          "LLM_PROVIDER=openai but OPENAI_API_KEY is not configured.",
-        );
-      }
-
-      const modelId =
-        options.modelId ?? config.LLM_MODEL ?? DEFAULT_OPENAI_MODEL;
-      return {
-        provider,
-        modelId,
-        model: createOpenAI({
-          apiKey: config.OPENAI_API_KEY,
-        }).languageModel(modelId),
-      };
-    }
-
-    throw new Error(
-      "No LLM provider is configured. Set ANTHROPIC_API_KEY or OPENAI_API_KEY locally, or deploy to an environment with a shared LLM variable group.",
-    );
-  }
-}