@promptbook/cli 0.112.0-112 → 0.112.0-114

package/apps/agents-server/src/utils/errorReporting/agentsServerSentryContext.ts

@@ -0,0 +1,203 @@
+import { BOOK_LANGUAGE_VERSION, PROMPTBOOK_ENGINE_VERSION } from '../../../../../src/version';
+import {
+    createSentrySdkTags,
+    resolveSentrySdkCommitHash,
+    resolveSentrySdkEnvironment,
+    resolveSentrySdkRelease,
+    resolveSentrySdkRepositoryBranch,
+} from './sentrySdkConfig';
+import type { SentryStorePayload } from './sentryStore';
+
+/**
+ * Shared deployment and runtime context added to every Agents Server Sentry event.
+ */
+type AgentsServerSentryContext = {
+    /**
+     * Sentry release identifier.
+     */
+    readonly release: string;
+
+    /**
+     * Sentry environment identifier.
+     */
+    readonly environment: string;
+
+    /**
+     * Filterable Sentry tags.
+     */
+    readonly tags: Record<string, string>;
+
+    /**
+     * Full non-secret diagnostic context.
+     */
+    readonly extra: Record<string, unknown>;
+};
+
+/**
+ * Adds shared Agents Server release, environment, version, deployment, git, and runtime details.
+ *
+ * @param payload - Event-specific Sentry payload.
+ * @returns Payload enriched with common Agents Server diagnostics.
+ *
+ * @private internal helper for Agents Server Sentry reporting
+ */
+export function enrichSentryStorePayloadWithAgentsServerContext(payload: SentryStorePayload): SentryStorePayload {
+    const context = createAgentsServerSentryContext();
+
+    return {
+        ...payload,
+        release: context.release,
+        environment: context.environment,
+        tags: {
+            ...context.tags,
+            ...payload.tags,
+        },
+        extra: {
+            ...context.extra,
+            ...payload.extra,
+        },
+    };
+}
+
+/**
+ * Creates a current Agents Server diagnostic context matching the admin About page metadata.
+ *
+ * @returns Common Sentry context for one event.
+ *
+ * @private internal helper for Agents Server Sentry reporting
+ */
+export function createAgentsServerSentryContext(): AgentsServerSentryContext {
+    const deploymentEnvironment = resolveSentrySdkEnvironment();
+    const appPackageVersion = normalizeOptionalString(process.env.npm_package_version) ?? PROMPTBOOK_ENGINE_VERSION;
+    const commitHash = resolveSentrySdkCommitHash();
+    const repositoryBranch = resolveSentrySdkRepositoryBranch();
+    const memoryUsage = process.memoryUsage();
+
+    return {
+        release: resolveSentrySdkRelease(),
+        environment: deploymentEnvironment,
+        tags: createSentrySdkTags(),
+        extra: {
+            agentsServer: {
+                versions: {
+                    promptbookEngineVersion: PROMPTBOOK_ENGINE_VERSION,
+                    bookLanguageVersion: BOOK_LANGUAGE_VERSION,
+                    appPackageVersion,
+                    appPackageName: normalizeOptionalString(process.env.npm_package_name),
+                    nextBuildId: normalizeOptionalString(process.env.NEXT_BUILD_ID),
+                    nextDistDirectory: normalizeOptionalString(process.env.NEXT_DIST_DIR),
+                    npmLifecycleEvent: normalizeOptionalString(process.env.npm_lifecycle_event),
+                    npmUserAgent: normalizeOptionalString(process.env.npm_config_user_agent),
+                },
+                deployment: {
+                    environment: deploymentEnvironment,
+                    vercelEnvironment: getFirstNonEmptyString(process.env.NEXT_PUBLIC_VERCEL_ENV, process.env.VERCEL_ENV),
+                    targetEnvironment: getFirstNonEmptyString(
+                        process.env.NEXT_PUBLIC_VERCEL_TARGET_ENV,
+                        process.env.VERCEL_TARGET_ENV,
+                    ),
+                    siteUrl: normalizeOptionalString(process.env.NEXT_PUBLIC_SITE_URL),
+                    vercelUrl: getFirstNonEmptyString(process.env.NEXT_PUBLIC_VERCEL_URL, process.env.VERCEL_URL),
+                    vercelBranchUrl: normalizeOptionalString(process.env.NEXT_PUBLIC_VERCEL_BRANCH_URL),
+                    vercelProductionUrl: normalizeOptionalString(process.env.NEXT_PUBLIC_VERCEL_PROJECT_PRODUCTION_URL),
+                    vercelRegion: normalizeOptionalString(process.env.VERCEL_REGION),
+                    repositoryRef: normalizeOptionalString(process.env.PROMPTBOOK_REPOSITORY_REF),
+                    supabaseTablePrefix: normalizeOptionalString(process.env.SUPABASE_TABLE_PREFIX),
+                    currentWorkingDirectory: process.cwd(),
+                },
+                git: {
+                    provider: getFirstNonEmptyString(
+                        process.env.NEXT_PUBLIC_VERCEL_GIT_PROVIDER,
+                        process.env.VERCEL_GIT_PROVIDER,
+                    ),
+                    repositoryOwner: getFirstNonEmptyString(
+                        process.env.NEXT_PUBLIC_VERCEL_GIT_REPO_OWNER,
+                        process.env.VERCEL_GIT_REPO_OWNER,
+                    ),
+                    repositorySlug: getFirstNonEmptyString(
+                        process.env.NEXT_PUBLIC_VERCEL_GIT_REPO_SLUG,
+                        process.env.VERCEL_GIT_REPO_SLUG,
+                    ),
+                    repositoryId: getFirstNonEmptyString(
+                        process.env.NEXT_PUBLIC_VERCEL_GIT_REPO_ID,
+                        process.env.VERCEL_GIT_REPO_ID,
+                    ),
+                    commitHash,
+                    previousCommitHash: getFirstNonEmptyString(
+                        process.env.NEXT_PUBLIC_VERCEL_GIT_PREVIOUS_SHA,
+                        process.env.VERCEL_GIT_PREVIOUS_SHA,
+                    ),
+                    branch: repositoryBranch,
+                    commitMessage: getFirstNonEmptyString(
+                        process.env.NEXT_PUBLIC_VERCEL_GIT_COMMIT_MESSAGE,
+                        process.env.VERCEL_GIT_COMMIT_MESSAGE,
+                    ),
+                    authorName: getFirstNonEmptyString(
+                        process.env.NEXT_PUBLIC_VERCEL_GIT_COMMIT_AUTHOR_NAME,
+                        process.env.VERCEL_GIT_COMMIT_AUTHOR_NAME,
+                    ),
+                    authorLogin: getFirstNonEmptyString(
+                        process.env.NEXT_PUBLIC_VERCEL_GIT_COMMIT_AUTHOR_LOGIN,
+                        process.env.VERCEL_GIT_COMMIT_AUTHOR_LOGIN,
+                    ),
+                    pullRequestId: getFirstNonEmptyString(
+                        process.env.NEXT_PUBLIC_VERCEL_GIT_PULL_REQUEST_ID,
+                        process.env.VERCEL_GIT_PULL_REQUEST_ID,
+                    ),
+                },
+                runtime: {
+                    nodeVersion: process.version,
+                    nodeEnvironment: normalizeOptionalString(process.env.NODE_ENV),
+                    nextRuntime: normalizeOptionalString(process.env.NEXT_RUNTIME),
+                    processId: process.pid,
+                    processUptimeSeconds: process.uptime(),
+                    hostname: getFirstNonEmptyString(process.env.HOSTNAME, process.env.COMPUTERNAME),
+                    platform: process.platform,
+                    architecture: process.arch,
+                    timezone: Intl.DateTimeFormat().resolvedOptions().timeZone || 'UTC',
+                },
+                memory: {
+                    rssBytes: memoryUsage.rss,
+                    heapUsedBytes: memoryUsage.heapUsed,
+                    heapTotalBytes: memoryUsage.heapTotal,
+                    externalBytes: memoryUsage.external,
+                    arrayBuffersBytes: memoryUsage.arrayBuffers ?? 0,
+                },
+            },
+        },
+    };
+}
+
+/**
+ * Returns the first non-empty string from a list.
+ *
+ * @param values - Candidate values in priority order.
+ * @returns First trimmed string or null.
+ */
+function getFirstNonEmptyString(...values: Array<string | null | undefined>): string | null {
+    for (const value of values) {
+        const normalizedValue = normalizeOptionalString(value);
+
+        if (normalizedValue) {
+            return normalizedValue;
+        }
+    }
+
+    return null;
+}
+
+/**
+ * Trims one optional environment value.
+ *
+ * @param value - Raw optional value.
+ * @returns Trimmed string or null.
+ */
+function normalizeOptionalString(value: string | null | undefined): string | null {
+    if (typeof value !== 'string') {
+        return null;
+    }
+
+    const normalizedValue = value.trim();
+
+    return normalizedValue || null;
+}

package/apps/agents-server/src/utils/errorReporting/registerServerErrorSentryLogging.ts

@@ -1,5 +1,8 @@
 import { inspect } from 'node:util';
+import * as Sentry from '@sentry/nextjs';
 import { DEFAULT_APPLICATION_ERROR_SERVER_NAME } from './applicationErrorHandling';
+import { createAgentsServerSentryContext } from './agentsServerSentryContext';
+import { enrichSentryStorePayloadWithAgentsServerContext } from './agentsServerSentryContext';
 import {
     createSentryTimestamp,
     resolveOptionalSentryDsn,
@@ -81,13 +84,17 @@ export function registerServerErrorSentryLogging(): void {
     console.error = (...consoleArguments: unknown[]): void => {
         loggingState.originalConsoleError?.(...consoleArguments);
 
+        const sentryPayload = createServerErrorSentryStorePayload(consoleArguments);
+
+        if (captureServerErrorWithSentrySdk(sentryPayload)) {
+            return;
+        }
+
         const sentryDsn = resolveOptionalSentryDsn();
         if (!sentryDsn) {
             return;
         }
 
-        const sentryPayload = createServerErrorSentryStorePayload(consoleArguments);
-
         // Never log reporting failures through `console.error`, otherwise a broken Sentry configuration would recurse.
         void sendSentryStorePayload(sentryPayload, sentryDsn).catch(() => undefined);
     };
@@ -144,7 +151,7 @@ function getServerErrorSentryLoggingState(): ServerErrorSentryLoggingState {
 function createServerErrorSentryStorePayload(consoleArguments: readonly unknown[]): SentryStorePayload {
     const loggedError = findLoggedErrorInfo(consoleArguments);
 
-    return {
+    return enrichSentryStorePayloadWithAgentsServerContext({
         platform: 'javascript',
         level: 'error',
         logger: SENTRY_SERVER_ERROR_LOGGER,
@@ -153,8 +160,6 @@ function createServerErrorSentryStorePayload(consoleArguments: readonly unknown[
         server_name: process.env.NEXT_PUBLIC_SERVER_NAME ?? DEFAULT_APPLICATION_ERROR_SERVER_NAME,
         tags: {
             source: 'agents-server.console-error',
-            nextRuntime: process.env.NEXT_RUNTIME ?? 'nodejs',
-            nodeEnv: process.env.NODE_ENV ?? 'unknown',
         },
         exception: loggedError
             ? {
@@ -169,11 +174,56 @@ function createServerErrorSentryStorePayload(consoleArguments: readonly unknown[
         extra: {
             consoleArguments: consoleArguments.map(serializeConsoleArgument),
             errorStack: loggedError?.stack ?? null,
-            vercelEnv: process.env.VERCEL_ENV ?? null,
-            vercelRegion: process.env.VERCEL_REGION ?? null,
-            vercelUrl: process.env.VERCEL_URL ?? null,
         },
-    };
+    });
+}
+
+/**
+ * Captures a server-side console error through the official Sentry SDK when it is initialized.
+ *
+ * @param sentryPayload - Structured event payload created from the original `console.error` call.
+ * @returns True when the SDK accepted the event.
+ */
+function captureServerErrorWithSentrySdk(sentryPayload: SentryStorePayload): boolean {
+    if (!Sentry.getClient()) {
+        return false;
+    }
+
+    const agentsServerContext = createAgentsServerSentryContext();
+
+    Sentry.captureException(createServerErrorSdkException(sentryPayload), {
+        level: sentryPayload.level,
+        tags: {
+            ...agentsServerContext.tags,
+            ...sentryPayload.tags,
+        },
+        extra: {
+            ...agentsServerContext.extra,
+            ...sentryPayload.extra,
+        },
+    });
+
+    return true;
+}
+
+/**
+ * Rebuilds an `Error` object from the structured Sentry payload so the SDK can parse stack frames.
+ *
+ * @param sentryPayload - Structured event payload created from the original `console.error` call.
+ * @returns Error object with the original stack when one was logged.
+ */
+function createServerErrorSdkException(sentryPayload: SentryStorePayload): Error {
+    const error = new Error(sentryPayload.message);
+    const exceptionValue = sentryPayload.exception?.values.at(0);
+    const errorStack = sentryPayload.extra?.errorStack;
+
+    error.name = exceptionValue?.type ?? 'Error';
+
+    if (typeof errorStack === 'string' && errorStack.trim()) {
+        error.stack = errorStack;
+    }
+
+    return error;
 }
 
 /**

package/apps/agents-server/src/utils/errorReporting/sendApplicationErrorReportToSentry.ts

@@ -1,4 +1,6 @@
+import * as Sentry from '@sentry/nextjs';
 import type { ApplicationErrorReportPayload } from './applicationErrorHandling';
+import { enrichSentryStorePayloadWithAgentsServerContext } from './agentsServerSentryContext';
 import {
     createSentryTimestamp,
     resolveRequiredSentryDsn,
@@ -18,7 +20,7 @@ const SENTRY_APPLICATION_ERROR_LOGGER = 'agents-server.application-error';
  * @returns Sentry store payload.
  */
 function createSentryStorePayload(report: ApplicationErrorReportPayload): SentryStorePayload {
-    return {
+    return enrichSentryStorePayloadWithAgentsServerContext({
         platform: 'javascript',
         level: 'error',
         logger: SENTRY_APPLICATION_ERROR_LOGGER,
@@ -44,7 +46,7 @@ function createSentryStorePayload(report: ApplicationErrorReportPayload): Sentry
             pageUrl: report.pageUrl ?? null,
             reportedAt: report.reportedAt,
         },
-    };
+    });
 }
 
 /**
@@ -53,5 +55,39 @@ function createSentryStorePayload(report: ApplicationErrorReportPayload): Sentry
  * @param report - Structured browser report payload.
  */
 export async function sendApplicationErrorReportToSentry(report: ApplicationErrorReportPayload): Promise<void> {
-    await sendSentryStorePayload(createSentryStorePayload(report), resolveRequiredSentryDsn());
+    const sentryPayload = createSentryStorePayload(report);
+
+    if (Sentry.getClient()) {
+        Sentry.captureException(createApplicationErrorSdkException(report, sentryPayload), {
+            level: sentryPayload.level,
+            tags: sentryPayload.tags,
+            extra: sentryPayload.extra,
+        });
+        await Sentry.flush(2000);
+        return;
+    }
+
+    await sendSentryStorePayload(sentryPayload, resolveRequiredSentryDsn());
+}
+
+/**
+ * Rebuilds an `Error` object from a browser application report so the SDK can parse stack frames.
+ *
+ * @param report - Browser-generated application error report.
+ * @param sentryPayload - Structured Sentry payload created from the report.
+ * @returns Error object with the original browser stack when available.
+ */
+function createApplicationErrorSdkException(
+    report: ApplicationErrorReportPayload,
+    sentryPayload: SentryStorePayload,
+): Error {
+    const error = new Error(sentryPayload.message);
+
+    error.name = report.errorName || 'Error';
+
+    if (report.errorStack?.trim()) {
+        error.stack = report.errorStack;
+    }
+
+    return error;
 }

package/apps/agents-server/src/utils/errorReporting/sentrySdkConfig.ts

@@ -0,0 +1,237 @@
+import { BOOK_LANGUAGE_VERSION, PROMPTBOOK_ENGINE_VERSION } from '../../../../../src/version';
+
+/**
+ * Default Sentry project DSN for Promptbook Agents Server telemetry.
+ *
+ * @private internal Sentry SDK configuration for Agents Server
+ */
+export const DEFAULT_SENTRY_DSN =
+    'https://986f734e9cddaeeec33e2a360f7d0b62@o4508778158030848.ingest.de.sentry.io/4511534509785168';
+
+/**
+ * Sentry organization slug used by build-time SDK tooling.
+ *
+ * @private internal Sentry SDK configuration for Agents Server
+ */
+export const SENTRY_ORGANIZATION = 'promptbook';
+
+/**
+ * Sentry project slug used by build-time SDK tooling.
+ *
+ * @private internal Sentry SDK configuration for Agents Server
+ */
+export const SENTRY_PROJECT = 's22';
+
+/**
+ * Performance tracing sample rate requested for the Agents Server.
+ *
+ * @private internal Sentry SDK configuration for Agents Server
+ */
+export const SENTRY_TRACES_SAMPLE_RATE = 1.0;
+
+/**
+ * Browser-side targets that should receive distributed tracing headers.
+ *
+ * @private internal Sentry SDK configuration for Agents Server
+ */
+export const SENTRY_TRACE_PROPAGATION_TARGETS: Array<string | RegExp> = [
+    'localhost',
+    /^\/api\//,
+    /^https:\/\/.*\.ptbk\.io\/api\//,
+    /^https:\/\/.*\.vercel\.app\/api\//,
+];
+
+/**
+ * Release name used for Agents Server Sentry events.
+ */
+const AGENTS_SERVER_SENTRY_RELEASE_NAME = 'promptbook-agents-server';
+
+/**
+ * Fallback text used in Sentry tags when a value is not configured.
+ */
+const UNKNOWN_SENTRY_CONTEXT_VALUE = 'unknown';
+
+/**
+ * Maximum length kept for Sentry tag values.
+ */
+const MAX_SENTRY_TAG_VALUE_LENGTH = 200;
+
+/**
+ * Resolves the browser-safe Sentry DSN.
+ *
+ * @returns Browser-safe Sentry DSN.
+ *
+ * @private internal Sentry SDK configuration for Agents Server
+ */
+export function resolveBrowserSentryDsn(): string {
+    return process.env.NEXT_PUBLIC_SENTRY_DSN ?? DEFAULT_SENTRY_DSN;
+}
+
+/**
+ * Resolves the server-side Sentry DSN.
+ *
+ * @returns Server-side Sentry DSN.
+ *
+ * @private internal Sentry SDK configuration for Agents Server
+ */
+export function resolveServerSentryDsn(): string {
+    return process.env.SENTRY_DSN ?? resolveBrowserSentryDsn();
+}
+
+/**
+ * Resolves the most specific deployment environment name available.
+ *
+ * @returns Environment name suitable for Sentry.
+ *
+ * @private internal Sentry SDK configuration for Agents Server
+ */
+export function resolveSentrySdkEnvironment(): string {
+    return (
+        getFirstNonEmptyString(
+            process.env.SENTRY_ENVIRONMENT,
+            process.env.NEXT_PUBLIC_VERCEL_TARGET_ENV,
+            process.env.VERCEL_TARGET_ENV,
+            process.env.NEXT_PUBLIC_VERCEL_ENV,
+            process.env.VERCEL_ENV,
+            process.env.PROMPTBOOK_REPOSITORY_REF,
+            process.env.NODE_ENV,
+        ) ?? UNKNOWN_SENTRY_CONTEXT_VALUE
+    );
+}
+
+/**
+ * Resolves the current deployment commit hash from common hosting environment variables.
+ *
+ * @returns Commit hash or null when unavailable.
+ *
+ * @private internal Sentry SDK configuration for Agents Server
+ */
+export function resolveSentrySdkCommitHash(): string | null {
+    return getFirstNonEmptyString(
+        process.env.NEXT_PUBLIC_VERCEL_GIT_COMMIT_SHA,
+        process.env.VERCEL_GIT_COMMIT_SHA,
+        process.env.PROMPTBOOK_COMMIT_SHA,
+        process.env.GIT_COMMIT_SHA,
+        process.env.COMMIT_SHA,
+        process.env.SOURCE_VERSION,
+    );
+}
+
+/**
+ * Resolves the current repository branch or deployment ref.
+ *
+ * @returns Repository branch/ref or null when unavailable.
+ *
+ * @private internal Sentry SDK configuration for Agents Server
+ */
+export function resolveSentrySdkRepositoryBranch(): string | null {
+    return getFirstNonEmptyString(
+        process.env.NEXT_PUBLIC_VERCEL_GIT_COMMIT_REF,
+        process.env.VERCEL_GIT_COMMIT_REF,
+        process.env.PROMPTBOOK_REPOSITORY_REF,
+        process.env.GIT_BRANCH,
+        process.env.BRANCH_NAME,
+    );
+}
+
+/**
+ * Resolves the Sentry release name for the current Agents Server build.
+ *
+ * @returns Release identifier suitable for Sentry.
+ *
+ * @private internal Sentry SDK configuration for Agents Server
+ */
+export function resolveSentrySdkRelease(): string {
+    const appPackageVersion = normalizeOptionalString(process.env.npm_package_version) ?? PROMPTBOOK_ENGINE_VERSION;
+    const commitHash = resolveSentrySdkCommitHash();
+
+    if (!commitHash) {
+        return `${AGENTS_SERVER_SENTRY_RELEASE_NAME}@${appPackageVersion}`;
+    }
+
+    return `${AGENTS_SERVER_SENTRY_RELEASE_NAME}@${appPackageVersion}+${commitHash}`;
+}
+
+/**
+ * Creates shared filterable Sentry tags for Agents Server events.
+ *
+ * @returns Sanitized Sentry tags.
+ *
+ * @private internal Sentry SDK configuration for Agents Server
+ */
+export function createSentrySdkTags(): Record<string, string> {
+    return createSentryTags({
+        promptbookEngineVersion: PROMPTBOOK_ENGINE_VERSION,
+        bookLanguageVersion: BOOK_LANGUAGE_VERSION,
+        appPackageVersion: normalizeOptionalString(process.env.npm_package_version) ?? PROMPTBOOK_ENGINE_VERSION,
+        commitHash: resolveSentrySdkCommitHash(),
+        repositoryBranch: resolveSentrySdkRepositoryBranch(),
+        deploymentEnvironment: resolveSentrySdkEnvironment(),
+        vercelEnvironment: getFirstNonEmptyString(process.env.NEXT_PUBLIC_VERCEL_ENV, process.env.VERCEL_ENV),
+        targetEnvironment: getFirstNonEmptyString(
+            process.env.NEXT_PUBLIC_VERCEL_TARGET_ENV,
+            process.env.VERCEL_TARGET_ENV,
+        ),
+        nextRuntime: process.env.NEXT_RUNTIME,
+        nodeEnvironment: process.env.NODE_ENV,
+        vercelRegion: process.env.VERCEL_REGION,
+    });
+}
+
+/**
+ * Creates Sentry tag values, preserving missing values as explicit `unknown` markers.
+ *
+ * @param values - Raw tag values.
+ * @returns Sanitized Sentry tags.
+ */
+function createSentryTags(values: Record<string, string | null | undefined>): Record<string, string> {
+    return Object.fromEntries(
+        Object.entries(values).map(([key, value]) => [key, sanitizeSentryTagValue(value)]),
+    ) as Record<string, string>;
+}
+
+/**
+ * Normalizes one value for use as a Sentry tag.
+ *
+ * @param value - Optional tag value.
+ * @returns Non-empty bounded tag value.
+ */
+function sanitizeSentryTagValue(value: string | null | undefined): string {
+    const normalizedValue = normalizeOptionalString(value) ?? UNKNOWN_SENTRY_CONTEXT_VALUE;
+
+    return normalizedValue.replace(/\s+/gu, ' ').slice(0, MAX_SENTRY_TAG_VALUE_LENGTH);
+}
+
+/**
+ * Returns the first non-empty string from a list.
+ *
+ * @param values - Candidate values in priority order.
+ * @returns First trimmed string or null.
+ */
+function getFirstNonEmptyString(...values: Array<string | null | undefined>): string | null {
+    for (const value of values) {
+        const normalizedValue = normalizeOptionalString(value);
+
+        if (normalizedValue) {
+            return normalizedValue;
+        }
+    }
+
+    return null;
+}
+
+/**
+ * Trims one optional environment value.
+ *
+ * @param value - Raw optional value.
+ * @returns Trimmed string or null.
+ */
+function normalizeOptionalString(value: string | null | undefined): string | null {
+    if (typeof value !== 'string') {
+        return null;
+    }
+
+    const normalizedValue = value.trim();
+
+    return normalizedValue || null;
+}

package/apps/agents-server/src/utils/errorReporting/sentryStore.ts

@@ -52,6 +52,16 @@ export type SentryStorePayload = {
      */
     message: string;
 
+    /**
+     * Sentry release identifier.
+     */
+    release?: string;
+
+    /**
+     * Deployment environment such as production, preview, or staging.
+     */
+    environment?: string;
+
     /**
      * Server/deployment name.
      */

package/apps/agents-server/src/utils/externalChatRunner/createExternalAgentRepositoryFiles.ts

@@ -53,9 +53,9 @@ function createExternalAgentRepositoryPackageJson(): string {
             scripts: {
                 start: 'npm run agent:run',
                 'agent:run':
-                    'npx ptbk agent-folder run-agent --agent github-copilot --model gpt-5.4 --thinking-level high --auto-pull --auto-push',
+                    'npx ptbk agent-folder run-agent --harness github-copilot --model gpt-5.4 --thinking-level high --auto-pull --auto-push',
                 'agent-local:run':
-                    'ts-node  ../../promptbook/src/cli/test/ptbk.ts agent-folder run-agent --agent github-copilot --model gpt-5.4 --auto-pull --auto-push',
+                    'ts-node  ../../promptbook/src/cli/test/ptbk.ts agent-folder run-agent --harness github-copilot --model gpt-5.4 --auto-pull --auto-push',
             },
         },
         null,