@percepta/create 3.4.1 → 3.4.3

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");
-  }
 }