@coursebuilder/server 0.1.0-canary.0.0c9beb2ae

package/src/resource-chat.ts

@@ -0,0 +1,371 @@
+import { NonRetriableError } from 'inngest'
+import { Liquid } from 'liquidjs'
+import { z } from 'zod'
+
+import type { ServerAdapter } from './adapter'
+import { logger } from './runtime/logger'
+import { LlmProviderConfig } from '@coursebuilder/core/providers/openai'
+import { PartyProviderConfig } from '@coursebuilder/core/providers/partykit'
+import { User } from '@coursebuilder/core/schemas'
+import {
+	CoreInngestFunctionInput,
+	CoreInngestHandler,
+	CoreInngestTrigger,
+} from './create-inngest-middleware'
+import {
+	ChatCompletionRequestMessage,
+	streamingChatPromptExecutor,
+} from './streaming-chat-prompt-executor'
+
+/** @deprecated Import event contracts from `@coursebuilder/core/events`. */
+export {
+	ChatResourceSchema,
+	type ChatResource,
+	RESOURCE_CHAT_REQUEST_EVENT,
+	type ResourceChat,
+} from '@coursebuilder/core/events/resource-chat'
+import {
+	ChatResourceSchema,
+	type ChatResource,
+	RESOURCE_CHAT_REQUEST_EVENT,
+} from '@coursebuilder/core/events/resource-chat'
+
+export const resourceChatConfig = {
+	id: `resource-chat`,
+	name: 'Resource Chat',
+	rateLimit: {
+		key: 'event.user.id',
+		limit: 5,
+		period: '1m' as `${number}m`,
+	},
+}
+
+export const resourceChatTrigger: CoreInngestTrigger = {
+	event: RESOURCE_CHAT_REQUEST_EVENT,
+}
+
+// Define ChatCompletionRequestMessageRoleEnum
+export enum ChatCompletionRequestMessageRoleEnum {
+	System = 'system',
+	User = 'user',
+	Assistant = 'assistant',
+	Tool = 'tool',
+}
+
+/**
+ * TODO: Cancellation conditions need to be added $$
+ */
+export const resourceChatHandler: CoreInngestHandler = async ({
+	event,
+	step,
+	openaiProvider,
+	partyProvider,
+	db,
+}: CoreInngestFunctionInput) => {
+	const resourceId = event.data.resourceId
+	const workflowTrigger = event.data.selectedWorkflow
+
+	const currentUserMessage = event.data.messages[event.data.messages.length - 1]
+
+	if (currentUserMessage?.content) {
+		await step.run(
+			`partykit broadcast user prompt [${resourceId}]`,
+			async () => {
+				await partyProvider.broadcastMessage({
+					body: {
+						body: currentUserMessage.content,
+						requestId: resourceId,
+						name: 'resource.chat.prompted',
+						// @ts-expect-error
+						userId: event.user.id,
+					},
+					roomId: resourceId,
+				})
+			},
+		)
+	}
+
+	const resource = await step.run('get the resource', async () => {
+		return db.getContentResource(resourceId)
+	})
+
+	if (!resource) {
+		throw new NonRetriableError(`Resource not found for id (${resourceId})`)
+	}
+
+	const videoResource = await step.run('get the video resource', async () => {
+		return db.getVideoResource(resource.resources?.[0]?.resource.id)
+	})
+
+	const messages = await resourceChatWorkflowExecutor({
+		db,
+		openaiProvider,
+		partyProvider,
+		step,
+		workflowTrigger,
+		resourceId,
+
+		resource: {
+			...videoResource,
+			...resource,
+			...resource.fields,
+			resources: resource.resources ?? [],
+		},
+		messages: event.data.messages,
+		// @ts-expect-error
+		user: event.user,
+	})
+
+	return { resource: { ...videoResource, ...resource }, messages }
+}
+
+/**
+ * loads the workflow from sanity based on the trigger and then executes the workflow using the `resource` as
+ * input that is parsed by liquid into the prompt
+ *
+ * This treats the system prompt as "special" from the loaded workflow since it is added to the beginning of the prompt
+ * in the chat context, but additional steps are executed as normal
+ *
+ * @param step
+ * @param workflowTrigger
+ * @param resourceId
+ * @param messages
+ * @param resource
+ * @param currentFeedback
+ */
+export async function resourceChatWorkflowExecutor({
+	step,
+	workflowTrigger,
+	resourceId,
+	messages,
+	resource,
+	user,
+	openaiProvider,
+	partyProvider,
+	db,
+	model,
+}: {
+	openaiProvider: LlmProviderConfig
+	partyProvider: PartyProviderConfig
+	db: ServerAdapter
+	resource: ChatResource
+	step: any
+	workflowTrigger: string
+	resourceId: string
+	messages: ChatCompletionRequestMessage[]
+	user: User
+	model?: string
+}) {
+	const basicPrompt = {
+		id: 'basic',
+		name: 'Basic',
+		type: 'prompt',
+		fields: {
+			body: `# Instructions
+Pause. Take a deep breath and think. This is important. Think step by step.
+
+You are serving as a writing assistant for a content creator that is publishing a {% if transcript %}video based{% endif %} post for software developers. The content creator will ask questions and expect concise answers that aren't corny or generic.
+
+Keep responses scoped to the post and it's direct contents. Do not include additional information.
+Do not include information that is not directly related to the post or the {% if transcript %}video{% endif %}.
+
+Use simple language.
+
+Use only most popular 2000 english words {% if transcript %}and words used in the transcript{% endif %}.
+Simple is better.
+Flourish is bad.
+**People will hate you if you try to sound clever.**
+
+{% if wordLevelSrt %} add screenshots from the video when they are relevant and would be useful to
+the reader using the following template replacing {{timestampInSeconds}} with the time noted in the transcript:
+
+![{{descriptiveAltTextForVisuallyImpaired}}](https://image.mux.com/{{muxPlaybackId}}/thumbnail.png?time={{timestampInSeconds}})
+be precise with the timestamps! {% if wordLevelSrt %} use this word level SRT to get the exact timestamp:
+
+word level srt start
+{{wordLevelSrt}} {% endif %}
+
+word level srt end
+{% endif %}
+
+Get it right and there's $200 cash gratuity in it for you ;)
+
+{% if transcript %}The goal is to build a really good written version of the existing video, not edit the video itself. The video is done.
+
+The post transcript is the final representation of the video. The post transcript is the source of truth.{% endif %}
+
+Keep the language simple and don't use words not in the post {% if transcript %}transcript{% endif %}.
+
+{% if transcript %}Do not make direct references to the video.
+Do not make direct references to the transcript.{% endif %}
+Do not make direct references to the content creator.
+Do not make direct references to 'the post'.
+Jump right to the point.
+
+Post Type: {{type}}
+
+Post Title: {{title}}
+
+{% if transcript %}Post Transcript: {{transcript}}{% endif %}
+
+Post Body: {{body}}
+`,
+		},
+	}
+
+	let prompt =
+		workflowTrigger === 'basic'
+			? basicPrompt
+			: await step.run('Load Prompt', async () => {
+					return db.getContentResource(workflowTrigger)
+				})
+
+	if (!prompt) {
+		prompt = basicPrompt
+	}
+
+	let systemPrompt: ChatCompletionRequestMessage = {
+		role: 'system',
+		content: prompt.fields.body,
+	}
+	let seedMessages: ChatCompletionRequestMessage[] = []
+
+	try {
+		const actionParsed = z
+			.array(
+				z.object({
+					role: z.enum([
+						ChatCompletionRequestMessageRoleEnum.System,
+						ChatCompletionRequestMessageRoleEnum.User,
+						ChatCompletionRequestMessageRoleEnum.Assistant,
+						ChatCompletionRequestMessageRoleEnum.Tool,
+					]),
+					content: z.string(),
+				}),
+			)
+			.parse(JSON.parse(prompt.fields.body)) as Array<{
+			role: ChatCompletionRequestMessageRoleEnum
+			content: string
+		}>
+
+		const actionMessages: ChatCompletionRequestMessage[] = []
+		for (const actionMessage of actionParsed) {
+			const liquidParsedContent = await step.run(
+				'parse json content',
+				async () => {
+					const engine = new Liquid()
+					const contentString =
+						typeof actionMessage.content === 'string'
+							? actionMessage.content
+							: JSON.stringify(actionMessage.content)
+					return await engine.parseAndRender(contentString, {
+						...resource,
+					})
+				},
+			)
+
+			actionMessages.push({
+				role: actionMessage.role,
+				content: liquidParsedContent,
+			})
+		}
+		if (actionMessages.length > 0) {
+			;[
+				systemPrompt = {
+					role: 'system',
+					content: prompt.fields.body,
+				},
+				...seedMessages
+			] = actionMessages
+		}
+	} catch (e: any) {
+		// if the prompt action content is not valid json, we assume it's just text
+		systemPrompt = await step.run(`parse system prompt`, async () => {
+			try {
+				const engine = new Liquid()
+				const originalSystemPrompt = systemPrompt // Store reference before reassignment
+				const contentString =
+					typeof originalSystemPrompt.content === 'string'
+						? originalSystemPrompt.content
+						: JSON.stringify(originalSystemPrompt.content)
+				return {
+					role: originalSystemPrompt.role,
+					content: await engine.parseAndRender(contentString || '', resource),
+				}
+			} catch (e: any) {
+				logger.error(e instanceof Error ? e : new Error(String(e)), {
+					context: 'co-gardener.resource-chat.system-prompt-render',
+					resourceId,
+				})
+				return {
+					role: 'system',
+					content: prompt.fields.body,
+				}
+			}
+		})
+	}
+
+	if (messages.length <= 2 && systemPrompt) {
+		messages = [systemPrompt, ...seedMessages, ...messages]
+	}
+
+	const currentUserMessage = messages[messages.length - 1]
+	const currentResourceMetadata = messages[messages.length - 2]
+
+	messages = await step.run('answer the user prompt', async () => {
+		if (!currentUserMessage) {
+			throw new Error('No user message')
+		}
+
+		const engine = new Liquid()
+		const currentUserContentString =
+			typeof currentUserMessage.content === 'string'
+				? currentUserMessage.content
+				: JSON.stringify(currentUserMessage.content)
+
+		currentUserMessage.content = await engine.parseAndRender(
+			currentUserContentString ?? '',
+			resource,
+		)
+
+		if (currentResourceMetadata) {
+			const metadataContentString =
+				typeof currentResourceMetadata.content === 'string'
+					? currentResourceMetadata.content
+					: JSON.stringify(currentResourceMetadata.content)
+			currentResourceMetadata.content = await engine.parseAndRender(
+				metadataContentString ?? '',
+				resource,
+			)
+		}
+
+		return streamingChatPromptExecutor({
+			requestId: resourceId,
+			promptMessages: messages,
+			model: prompt.fields.model || model || 'gpt-4-turbo',
+			provider: openaiProvider,
+		})
+	})
+
+	await step.run(`partykit broadcast [${resourceId}]`, async () => {
+		return await partyProvider.broadcastMessage({
+			body: {
+				body: messages,
+				requestId: resourceId,
+				name: 'resource.chat.completed',
+				metadata: {
+					workflow: workflowTrigger,
+				},
+			},
+			roomId: resourceId,
+		})
+	})
+
+	return messages
+}
+
+export const resourceChat = {
+	config: resourceChatConfig,
+	trigger: resourceChatTrigger,
+	handler: resourceChatHandler,
+}

package/src/runtime/actions.ts

@@ -0,0 +1,25 @@
+import { CourseBuilderAction } from '@coursebuilder/core/types'
+
+const actions: CourseBuilderAction[] = [
+	'webhook',
+	'srt',
+	'session',
+	'subscribe-to-list',
+	'checkout',
+	'redeem',
+	'prices-formatted',
+	'subscriber',
+	'purchases',
+	'lookup',
+	'claimed',
+	'nameUpdate',
+	'transfer',
+	'refund',
+	'create-magic-link',
+]
+
+export function isCourseBuilderAction(
+	action: string,
+): action is CourseBuilderAction {
+	return actions.includes(action as CourseBuilderAction)
+}

package/src/runtime/assert.ts

@@ -0,0 +1,55 @@
+import type { ServerAdapter } from '../adapter'
+import {
+	MissingAdapter,
+	MissingAdapterMethods,
+	UnsupportedStrategy,
+} from '@coursebuilder/core/errors'
+import { RequestInternal } from '@coursebuilder/core/types'
+
+import { CourseBuilderConfig } from '../http'
+import { WarningCode } from './logger'
+
+type ConfigError = MissingAdapter | MissingAdapterMethods | UnsupportedStrategy
+
+let hasTranscript = false
+let warned = false
+
+export function assertConfig(
+	request: RequestInternal,
+	options: CourseBuilderConfig,
+): ConfigError | WarningCode[] {
+	const { url } = request
+	const warnings: WarningCode[] = []
+
+	if (!warned && options.debug) warnings.push('debug-enabled')
+
+	// Keep track of webauthn providers that use conditional UI
+
+	for (const p of options.providers) {
+		const provider = typeof p === 'function' ? p() : p
+		if (provider.type === 'transcription') {
+			hasTranscript = true
+		}
+	}
+
+	const { adapter } = options
+
+	let requiredMethods: (keyof ServerAdapter)[] = []
+
+	if (hasTranscript) {
+	}
+
+	if (adapter) {
+		const missing = requiredMethods.filter((m) => !(m in adapter))
+
+		if (missing.length) {
+			return new MissingAdapterMethods(
+				`Required adapter methods were missing: ${missing.join(', ')}`,
+			)
+		}
+	}
+
+	if (!warned) warned = true
+
+	return warnings
+}

package/src/runtime/cookie.ts

@@ -0,0 +1,12 @@
+import { CookieOption, CookiesOptions } from '@coursebuilder/core/types'
+
+export interface Cookie extends CookieOption {
+	value: string
+}
+
+export function defaultCookies(useSecureCookies: boolean) {
+	const cookiePrefix = useSecureCookies ? '__Secure-' : ''
+	return {
+		// default cookie options
+	} as const satisfies CookiesOptions
+}

package/src/runtime/env.test.ts

@@ -0,0 +1,49 @@
+import { beforeEach, describe, expect, it } from 'vitest'
+
+import type { CourseBuilderConfig } from '../http'
+import { setEnvDefaults } from './env'
+import Deepgram from '@coursebuilder/core/providers/deepgram'
+
+const testConfig: CourseBuilderConfig = {
+	providers: [Deepgram],
+	baseUrl: '/coursebuilder',
+	authConfig: {},
+}
+
+let courseBuilderConfig: CourseBuilderConfig
+
+beforeEach(() => {
+	courseBuilderConfig = { ...testConfig } // clone
+})
+
+describe('config is inferred from environment variables', () => {
+	it('providers (client id, client secret, issuer, api key)', () => {
+		const env = {
+			COURSEBUILDER_DEEPGRAM_API_KEY: 'fdsa',
+		}
+		setEnvDefaults(env, courseBuilderConfig)
+		const [p1] = courseBuilderConfig.providers
+		// @ts-expect-error
+		expect(p1.apiKey).toBe(env.COURSEBUILDER_DEEPGRAM_API_KEY)
+	})
+
+	it('COURSEBUILDER_URL', () => {
+		const env = { COURSEBUILDER_URL: 'http://n/api/coursebuilder' }
+		setEnvDefaults(env, courseBuilderConfig)
+		expect(courseBuilderConfig.basePath).toBe('/api/coursebuilder')
+	})
+
+	it('COURSEBUILDER_URL + prefer config', () => {
+		const env = { COURSEBUILDER_URL: 'http://n/api/coursebuilder' }
+		const fromConfig = '/basepath-from-config'
+		courseBuilderConfig.basePath = fromConfig
+		setEnvDefaults(env, courseBuilderConfig)
+		expect(courseBuilderConfig.basePath).toBe(fromConfig)
+	})
+
+	it('COURSEBUILDER_URL, but invalid value', () => {
+		const env = { COURSEBUILDER_URL: 'secret' }
+		setEnvDefaults(env, courseBuilderConfig)
+		expect(courseBuilderConfig.basePath).toBe('/coursebuilder')
+	})
+})

package/src/runtime/env.ts

@@ -0,0 +1,63 @@
+import { CourseBuilderAction } from '@coursebuilder/core/types'
+
+import { CourseBuilderConfig } from '../http'
+import { logger } from './logger.js'
+
+/** Set default env variables on the config object */
+export function setEnvDefaults(envObject: any, config: CourseBuilderConfig) {
+	try {
+		const url = envObject.COURSEBUILDER_URL
+		if (url && !config.basePath) config.basePath = new URL(url).pathname
+	} catch {
+	} finally {
+		config.basePath ??= `/coursebuilder`
+	}
+
+	config.providers = config.providers.map((p) => {
+		const finalProvider = typeof p === 'function' ? p({}) : p
+		const ID = finalProvider.id.toUpperCase()
+		if (finalProvider.type === 'transcription') {
+			finalProvider.apiKey ??= envObject[`COURSEBUILDER_${ID}_API_KEY`]
+		}
+		return finalProvider
+	})
+}
+
+export function createActionURL(
+	action: CourseBuilderAction,
+	protocol: string,
+	headers: Headers,
+	envObject: any,
+	basePath?: string,
+): URL {
+	let envUrl = envObject.COURSEBUILDER_URL
+
+	let url: URL
+	if (envUrl) {
+		url = new URL(envUrl)
+		if (basePath && basePath !== '/' && url.pathname !== '/') {
+			logger.debug(
+				url.pathname === basePath
+					? 'env-url-basepath-redundant'
+					: 'env-url-basepath-mismatch',
+			)
+			url.pathname = '/'
+		}
+	} else {
+		const detectedHost = headers.get('x-forwarded-host') ?? headers.get('host')
+		const detectedProtocol =
+			headers.get('x-forwarded-proto') ?? protocol ?? 'https'
+
+		url = new URL(`${detectedProtocol}://${detectedHost}`)
+	}
+
+	// remove trailing slash
+	const sanitizedUrl = url.toString().replace(/\/$/, '')
+
+	if (basePath) {
+		// remove leading and trailing slash
+		const sanitizedBasePath = basePath?.replace(/(^\/|\/$)/g, '') ?? ''
+		return new URL(`${sanitizedUrl}/${sanitizedBasePath}/${action}`)
+	}
+	return new URL(`${sanitizedUrl}/${action}`)
+}

package/src/runtime/init.ts

@@ -0,0 +1,112 @@
+import { AdapterError } from '@coursebuilder/core/errors'
+import {
+	CallbacksOptions,
+	InternalOptions,
+	RequestInternal,
+} from '@coursebuilder/core/types'
+
+import { CourseBuilderConfig } from '../http'
+import * as cookie from './cookie.js'
+import { logger, LoggerInstance } from './logger'
+import { merge } from './merge'
+import parseProviders from './providers'
+
+interface InitParams {
+	url: URL
+	courseBuilderOptions: CourseBuilderConfig
+	providerId?: string
+	action: InternalOptions['action']
+	isPost: boolean
+	cookies: RequestInternal['cookies']
+}
+
+export async function init({
+	url,
+	courseBuilderOptions,
+	providerId,
+	action,
+	isPost,
+	cookies: reqCookies,
+}: InitParams): Promise<{
+	options: InternalOptions
+	cookies: cookie.Cookie[]
+}> {
+	const { providers, provider } = parseProviders({
+		providers: courseBuilderOptions.providers,
+		url,
+		providerId,
+		options: courseBuilderOptions,
+	})
+
+	const maxAge = 30 * 24 * 60 * 60
+
+	const options: InternalOptions = {
+		debug: false,
+		pages: {},
+		...courseBuilderOptions,
+		url,
+		action,
+		// @ts-expect-errors
+		provider,
+		cookies: merge(
+			{},
+			cookie.defaultCookies(
+				courseBuilderOptions.useSecureCookies ?? url.protocol === 'https:',
+			),
+			courseBuilderOptions.cookies || {},
+			reqCookies,
+		),
+		providers,
+		adapter: adapterErrorHandler(courseBuilderOptions.adapter, logger),
+		callbacks: { ...defaultCallbacks, ...courseBuilderOptions.callbacks },
+		logger,
+		getCurrentUser: courseBuilderOptions.getCurrentUser,
+	}
+
+	// Convert request cookies to Cookie[] format for actions
+	const cookies: cookie.Cookie[] = Object.entries(reqCookies || {})
+		.filter((entry): entry is [string, string] => typeof entry[1] === 'string')
+		.map(([name, value]) => ({
+			name,
+			value,
+			options: {},
+		}))
+
+	logger.debug('init.request-cookies', {
+		rawCookieKeys: Object.keys(reqCookies || {}),
+		convertedCount: cookies.length,
+		hasSl_ref: cookies.some((c) => c.name === 'sl_ref'),
+	})
+
+	return { options, cookies }
+}
+
+type Method = (...args: any[]) => Promise<any>
+
+export const defaultCallbacks: CallbacksOptions = {
+	session(payload) {
+		return payload
+	},
+}
+
+function adapterErrorHandler(
+	adapter: CourseBuilderConfig['adapter'],
+	logger: LoggerInstance,
+) {
+	if (!adapter) return
+
+	return Object.keys(adapter).reduce<any>((acc, name) => {
+		acc[name] = async (...args: any[]) => {
+			try {
+				logger.debug(`adapter_${name}`, { args })
+				const method: Method = adapter[name as keyof Method]
+				return await method(...args)
+			} catch (e) {
+				const error = new AdapterError(e as Error)
+				logger.error(error)
+				throw error
+			}
+		}
+		return acc
+	}, {})
+}

package/src/runtime/logger.ts

@@ -0,0 +1,6 @@
+export { logger, setLogger } from '@coursebuilder/utils/logger'
+export type {
+	LogAttributes,
+	LoggerInstance,
+	WarningCode,
+} from '@coursebuilder/utils/logger'