@percepta/create 3.4.2 → 3.5.0

package/templates/webapp/agent-skills/access-control.md

@@ -140,7 +140,7 @@ If `access:reconcile` should repair missing system links for a resource type, pr
 
 ## Permissioned Postgres Tables
 
-When a Drizzle table backs a SpiceDB resource, bind the table to the resource manifest once. Keep Zed as the permission source of truth; the table binding only records object identity, relationship columns, and which field groups require which permissions.
+When a Drizzle table backs a SpiceDB resource, bind the table to the resource manifest once. Keep Zed as the permission source of truth; the table binding records object identity, relationship columns, and which field groups require which permissions. It does not automatically write to SpiceDB.
 
 ```ts
 import {
@@ -192,6 +192,29 @@ const checks = createColumnPermissionChecks(employeeAccess, {
 const [canReadSalary] = await getAccessControl().permissions.canMany(checks);
 ```
 
+Use a lifecycle sync wrapper in repositories/services that create, update, or delete rows with SpiceDB-backed relationships. Configure it once with either direct SpiceDB writes for authorization changes that must be visible immediately, or outbox enqueueing for transactional retry.
+
+```ts
+import {
+  createPermissionedResourceLifecycleSync,
+} from "@percepta/access-control/drizzle";
+
+const employeeLifecycle = createPermissionedResourceLifecycleSync({
+  apply: {
+    client: getAccessControl().client,
+    mode: "direct",
+  },
+  binding: employeeAccess,
+  system: accessManifest.system.ref(),
+});
+
+await employeeLifecycle.afterInsert(createdEmployee);
+await employeeLifecycle.afterUpdate(existingEmployee, updatedEmployee);
+await employeeLifecycle.afterDelete(deletedEmployee);
+```
+
+For transactional outbox sync, pass `apply: { mode: "outbox", enqueue }`; the queued event contains either relationship mutations or a resource delete filter. Hard deletes use resource-filter cleanup by default so relationships not represented by local columns are removed too. Pass `{ cleanup: "derived-mutations" }` to `afterDelete()` only when the resource should keep out-of-band relationships.
+
 Do not model ordinary Postgres columns as SpiceDB objects. Model business permissions in Zed, group columns under those permissions in the table binding, then enforce the binding at the API/data boundary.
 
 ## App Code

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/drizzle.config.ts

@@ -1,7 +1,7 @@
 import { loadEnvConfig } from "@next/env";
+import { getPgSearchPathOption } from "@percepta/database";
 import type { Config } from "drizzle-kit";
 import { getEnvConfig } from "./src/config/getEnvConfig";
-import { getPgSearchPathOption } from "./src/drizzle/searchPath";
 
 loadEnvConfig(process.cwd());
 

package/templates/webapp/package.json.template

@@ -17,11 +17,11 @@
     "access:apply-local": "pnpm --dir ../.. run access:apply-local",
     "auth:db:setup-and-migrate": "pnpm --dir ../.. run auth:db:setup-and-migrate",
     "inngest:dev": "pnpm dlx inngest-cli@latest dev -u http://localhost:3000/api/inngest",
-    "db:generate": "tsx ./scripts/generate-migrations.ts",
-    "db:migrate": "tsx ./scripts/migrate.ts",
-    "db:setup": "tsx ./scripts/setup-database.ts",
+    "db:generate": "percepta-db generate-migrations",
+    "db:migrate": "percepta-db migrate --database __DB_NAME__",
+    "db:setup": "percepta-db setup --database __DB_NAME__",
     "db:setup-and-migrate": "pnpm db:setup && pnpm db:migrate",
-    "db:setup-readonly": "tsx ./scripts/setup-readonly-user.ts",
+    "db:setup-readonly": "percepta-db setup-readonly --database __DB_NAME__",
     "db:studio": "pnpm db:setup-and-migrate && drizzle-kit studio",
     "db:seed": "tsx ./scripts/seed.ts",
     "deploy:percepta-test": "percepta-deploy percepta-test --app __APP_NAME__ --repo __REPO_NAME__",
@@ -33,10 +33,7 @@
     "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",
     "@aws-sdk/credential-providers": "^3.913.0",
     "@aws-sdk/s3-request-presigner": "^3.891.0",
@@ -48,9 +45,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 +52,13 @@
     "@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/database": "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/drizzle/db.ts

@@ -1,8 +1,7 @@
+import { getPgSearchPathOption, getPgSslConfig } from "@percepta/database";
 import { type NodePgDatabase, drizzle } from "drizzle-orm/node-postgres";
 import { Pool } from "pg";
 import { getEnvConfig } from "../config/getEnvConfig";
-import { getPgSearchPathOption } from "./searchPath";
-import { getPgSslConfig } from "./ssl";
 
 export const { client, db } = createDb();
 

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;