fix(meeting-document): hold quota for in-flight generation claims
This commit is contained in:
Yun Chan
parent
f4724ddf53
commit
b35676c75c
5 changed files with 994 additions and 179 deletions
|
|
@ -0,0 +1,219 @@
|
|||
import {
|
||||
assertEquals,
|
||||
assertRejects,
|
||||
} from 'https://deno.land/std@0.224.0/assert/mod.ts'
|
||||
import type { GenerateMeetingDocumentRequest } from '../_shared/meeting-document-contract.ts'
|
||||
import {
|
||||
buildProviderRequest,
|
||||
type GenerationFailureCode,
|
||||
generateMeetingDocument,
|
||||
mapDatabaseError,
|
||||
type MeetingDocumentStore,
|
||||
parseClaim,
|
||||
PROVIDER_MAX_TOKENS,
|
||||
type ProviderOutcome,
|
||||
type ProviderRequest,
|
||||
type RpcResult,
|
||||
} from './generation.ts'
|
||||
|
||||
const actorId = '44444444-4444-4444-8444-444444444444'
|
||||
const request: GenerateMeetingDocumentRequest = {
|
||||
meetingId: '11111111-1111-4111-8111-111111111111',
|
||||
templateId: '22222222-2222-4222-8222-222222222222',
|
||||
idempotencyKey: '33333333-3333-4333-8333-333333333333',
|
||||
title: 'Weekly summary',
|
||||
model: 'claude-haiku-4-5-20251001',
|
||||
}
|
||||
|
||||
const claimedPayload = {
|
||||
claimed: true,
|
||||
status: 'processing',
|
||||
documentId: null,
|
||||
meetingTitle: 'Weekly sync',
|
||||
documentTitle: 'Weekly summary',
|
||||
templateType: 'custom',
|
||||
systemPrompt: 'Summarize.',
|
||||
transcript: 'A: hello',
|
||||
model: 'claude-haiku-4-5-20251001',
|
||||
}
|
||||
|
||||
const providerBody = {
|
||||
content: [{ type: 'text', text: 'Generated body' }],
|
||||
usage: { input_tokens: 10, output_tokens: 20 },
|
||||
}
|
||||
|
||||
interface Harness {
|
||||
store: MeetingDocumentStore
|
||||
providerCalls: ProviderRequest[]
|
||||
failures: GenerationFailureCode[]
|
||||
commits: number
|
||||
logs: string[]
|
||||
}
|
||||
|
||||
function harness(options: {
|
||||
claim?: RpcResult
|
||||
provider?: () => Promise<ProviderOutcome>
|
||||
commit?: () => Promise<RpcResult>
|
||||
findDocument?: RpcResult
|
||||
} = {}): Harness & { run: () => ReturnType<typeof generateMeetingDocument> } {
|
||||
const state: Harness = {
|
||||
store: undefined as unknown as MeetingDocumentStore,
|
||||
providerCalls: [],
|
||||
failures: [],
|
||||
commits: 0,
|
||||
logs: [],
|
||||
}
|
||||
state.store = {
|
||||
claim: () => Promise.resolve(options.claim ?? { data: claimedPayload, error: null }),
|
||||
markFailed: (_actor, _key, code) => {
|
||||
state.failures.push(code)
|
||||
return Promise.resolve(null)
|
||||
},
|
||||
commit: () => {
|
||||
state.commits += 1
|
||||
return options.commit?.() ?? Promise.resolve({
|
||||
data: { idempotent: false, document: { id: 'doc-1' } },
|
||||
error: null,
|
||||
})
|
||||
},
|
||||
findDocument: () => Promise.resolve(options.findDocument ?? { data: { id: 'doc-1' }, error: null }),
|
||||
}
|
||||
let clock = 1_000
|
||||
return Object.assign(state, {
|
||||
run: () => generateMeetingDocument(actorId, request, {
|
||||
store: state.store,
|
||||
provider: {
|
||||
generate: (payload: ProviderRequest) => {
|
||||
state.providerCalls.push(payload)
|
||||
return options.provider?.() ?? Promise.resolve<ProviderOutcome>({ kind: 'ok', body: providerBody })
|
||||
},
|
||||
},
|
||||
now: () => (clock += 250),
|
||||
log: (message: string) => { state.logs.push(message) },
|
||||
}),
|
||||
})
|
||||
}
|
||||
|
||||
Deno.test('a claim rejected for quota never reaches the provider', async () => {
|
||||
const h = harness({
|
||||
claim: { data: null, error: { code: 'P0001', message: 'generation_quota_exceeded' } },
|
||||
})
|
||||
assertEquals(await h.run(), { status: 429, body: { error: 'quota_exceeded' } })
|
||||
assertEquals(h.providerCalls.length, 0)
|
||||
assertEquals(h.commits, 0)
|
||||
})
|
||||
|
||||
Deno.test('regression r1-17: an unexpected error after claim releases the in-flight quota unit', async () => {
|
||||
const h = harness({ commit: () => Promise.reject(new Error('socket hang up')) })
|
||||
await assertRejects(() => h.run(), Error, 'socket hang up')
|
||||
assertEquals(h.failures, ['commit_failed'])
|
||||
})
|
||||
|
||||
Deno.test('an unexpected provider adapter error also releases the claim', async () => {
|
||||
const h = harness({ provider: () => Promise.reject(new TypeError('boom')) })
|
||||
await assertRejects(() => h.run(), TypeError)
|
||||
assertEquals(h.failures, ['commit_failed'])
|
||||
assertEquals(h.commits, 0)
|
||||
})
|
||||
|
||||
Deno.test('successful generation commits once and returns the document', async () => {
|
||||
const h = harness()
|
||||
assertEquals(await h.run(), {
|
||||
status: 200,
|
||||
body: { document: { id: 'doc-1' }, idempotent: false },
|
||||
})
|
||||
assertEquals(h.providerCalls.length, 1)
|
||||
assertEquals(h.failures, [])
|
||||
})
|
||||
|
||||
Deno.test('provider failures mark the claim failed with the matching code', async () => {
|
||||
const cases: Array<[ProviderOutcome, number, string, GenerationFailureCode]> = [
|
||||
[{ kind: 'timeout' }, 504, 'provider_timeout', 'provider_timeout'],
|
||||
[{ kind: 'network_error' }, 502, 'provider_request_failed', 'provider_request_failed'],
|
||||
[{ kind: 'http_error', status: 529 }, 502, 'provider_request_failed', 'provider_request_failed'],
|
||||
[{ kind: 'ok', body: null }, 502, 'provider_invalid_response', 'provider_invalid_response'],
|
||||
]
|
||||
for (const [outcome, status, error, failure] of cases) {
|
||||
const h = harness({ provider: () => Promise.resolve(outcome) })
|
||||
assertEquals(await h.run(), { status, body: { error } })
|
||||
assertEquals(h.failures, [failure])
|
||||
assertEquals(h.commits, 0)
|
||||
}
|
||||
})
|
||||
|
||||
Deno.test('commit quota rejection marks quota_exceeded and returns 429', async () => {
|
||||
const h = harness({
|
||||
commit: () => Promise.resolve({ data: null, error: { code: 'P0001', message: 'generation_quota_exceeded' } }),
|
||||
})
|
||||
assertEquals(await h.run(), { status: 429, body: { error: 'quota_exceeded' } })
|
||||
assertEquals(h.failures, ['quota_exceeded'])
|
||||
})
|
||||
|
||||
Deno.test('other commit errors mark commit_failed and return 500', async () => {
|
||||
const h = harness({
|
||||
commit: () => Promise.resolve({ data: null, error: { code: '55000', message: 'not committable' } }),
|
||||
})
|
||||
assertEquals(await h.run(), { status: 500, body: { error: 'commit_failed' } })
|
||||
assertEquals(h.failures, ['commit_failed'])
|
||||
})
|
||||
|
||||
Deno.test('claim without prompt or transcript is released', async () => {
|
||||
const h = harness({ claim: { data: { ...claimedPayload, transcript: null }, error: null } })
|
||||
assertEquals(await h.run(), { status: 500, body: { error: 'internal_error' } })
|
||||
assertEquals(h.failures, ['commit_failed'])
|
||||
assertEquals(h.providerCalls.length, 0)
|
||||
})
|
||||
|
||||
Deno.test('replays return the stored document or a conflict without provider work', async () => {
|
||||
const succeeded = harness({
|
||||
claim: {
|
||||
data: { ...claimedPayload, claimed: false, status: 'succeeded', documentId: 'doc-1', systemPrompt: null, transcript: null },
|
||||
error: null,
|
||||
},
|
||||
})
|
||||
assertEquals(await succeeded.run(), {
|
||||
status: 200,
|
||||
body: { document: { id: 'doc-1' }, idempotent: true },
|
||||
})
|
||||
|
||||
const inProgress = harness({
|
||||
claim: { data: { ...claimedPayload, claimed: false, systemPrompt: null, transcript: null }, error: null },
|
||||
})
|
||||
assertEquals(await inProgress.run(), { status: 409, body: { error: 'generation_in_progress' } })
|
||||
|
||||
const failed = harness({
|
||||
claim: { data: { ...claimedPayload, claimed: false, status: 'failed', systemPrompt: null, transcript: null }, error: null },
|
||||
})
|
||||
assertEquals(await failed.run(), { status: 409, body: { error: 'generation_failed' } })
|
||||
|
||||
for (const h of [succeeded, inProgress, failed]) {
|
||||
assertEquals(h.providerCalls.length, 0)
|
||||
assertEquals(h.failures, [])
|
||||
}
|
||||
})
|
||||
|
||||
Deno.test('parseClaim rejects a null claimed flag', () => {
|
||||
assertEquals(parseClaim({ ...claimedPayload, claimed: null }), null)
|
||||
assertEquals(parseClaim(claimedPayload)?.claimed, true)
|
||||
})
|
||||
|
||||
Deno.test('mapDatabaseError keeps the HTTP contract', () => {
|
||||
const log = () => {}
|
||||
assertEquals(mapDatabaseError({ code: '42501' }, log).status, 403)
|
||||
assertEquals(mapDatabaseError({ code: 'P0002' }, log).status, 404)
|
||||
assertEquals(mapDatabaseError({ code: '22023' }, log).status, 400)
|
||||
assertEquals(mapDatabaseError({ code: 'P0001', message: 'generation_quota_exceeded' }, log), {
|
||||
status: 429,
|
||||
body: { error: 'quota_exceeded' },
|
||||
})
|
||||
assertEquals(mapDatabaseError(null, log), { status: 500, body: { error: 'internal_error' } })
|
||||
})
|
||||
|
||||
Deno.test('buildProviderRequest bounds output and wraps the template prompt', () => {
|
||||
const payload = buildProviderRequest({ ...claimedPayload, status: 'processing' } as Parameters<typeof buildProviderRequest>[0])
|
||||
assertEquals(payload.max_tokens, PROVIDER_MAX_TOKENS)
|
||||
assertEquals(payload.stream, false)
|
||||
assertEquals(payload.model, 'claude-haiku-4-5-20251001')
|
||||
assertEquals(payload.messages.length, 1)
|
||||
assertEquals(payload.system.includes('Summarize.'), true)
|
||||
})
|
||||
|
|
@ -0,0 +1,273 @@
|
|||
// Application core of generate-meeting-document.
|
||||
//
|
||||
// The flow (claim -> provider -> commit, with a failure marker on every exit
|
||||
// after a successful claim) depends only on the ports below, so it can be
|
||||
// exercised without Supabase, Anthropic or an HTTP runtime. index.ts is the
|
||||
// adapter that wires real clients into these ports and turns the result into a
|
||||
// Response.
|
||||
//
|
||||
// Quota: the claim RPC holds one unit of the user's allowance while the request
|
||||
// is 'processing' (migration 20260928000037). Every path that leaves a claimed
|
||||
// request unfinished must therefore call markFailed so the unit is released
|
||||
// immediately instead of waiting for the lease to expire.
|
||||
|
||||
import { buildMeetingDocumentSystemPrompt } from '../_shared/generative-ai-safety.ts'
|
||||
import {
|
||||
type GenerateMeetingDocumentRequest,
|
||||
parseProviderDocumentResult,
|
||||
type ProviderDocumentResult,
|
||||
} from '../_shared/meeting-document-contract.ts'
|
||||
|
||||
export type GenerationFailureCode =
|
||||
| 'provider_timeout'
|
||||
| 'provider_request_failed'
|
||||
| 'provider_invalid_response'
|
||||
| 'quota_exceeded'
|
||||
| 'commit_failed'
|
||||
|
||||
export interface DatabaseError {
|
||||
code?: string
|
||||
message?: string
|
||||
}
|
||||
|
||||
export interface RpcResult {
|
||||
data: unknown
|
||||
error: DatabaseError | null
|
||||
}
|
||||
|
||||
export interface GenerationHttpResult {
|
||||
status: number
|
||||
body: Record<string, unknown>
|
||||
}
|
||||
|
||||
export interface ClaimResult {
|
||||
claimed: boolean
|
||||
status: 'processing' | 'succeeded' | 'failed'
|
||||
documentId: string | null
|
||||
meetingTitle: string
|
||||
documentTitle: string
|
||||
templateType: string
|
||||
systemPrompt: string | null
|
||||
transcript: string | null
|
||||
model: string
|
||||
}
|
||||
|
||||
export interface ProviderRequest {
|
||||
model: string
|
||||
max_tokens: number
|
||||
system: string
|
||||
messages: Array<{ role: 'user'; content: string }>
|
||||
stream: false
|
||||
}
|
||||
|
||||
/** Outcome of one provider call, already classified by the adapter. */
|
||||
export type ProviderOutcome =
|
||||
| { kind: 'ok'; body: unknown }
|
||||
| { kind: 'timeout' }
|
||||
| { kind: 'network_error' }
|
||||
| { kind: 'http_error'; status: number }
|
||||
|
||||
/** Persistence port: the four RPC/table operations the flow needs. */
|
||||
export interface MeetingDocumentStore {
|
||||
claim(actorId: string, request: GenerateMeetingDocumentRequest): Promise<RpcResult>
|
||||
markFailed(actorId: string, idempotencyKey: string, code: GenerationFailureCode): Promise<DatabaseError | null>
|
||||
commit(
|
||||
actorId: string,
|
||||
idempotencyKey: string,
|
||||
result: ProviderDocumentResult,
|
||||
latencyMs: number,
|
||||
): Promise<RpcResult>
|
||||
findDocument(actorId: string, documentId: string): Promise<RpcResult>
|
||||
}
|
||||
|
||||
/** Provider port: sends one document request and classifies the transport outcome. */
|
||||
export interface MeetingDocumentProvider {
|
||||
generate(request: ProviderRequest): Promise<ProviderOutcome>
|
||||
}
|
||||
|
||||
export type GenerationLogger = (message: string, context?: Record<string, unknown>) => void
|
||||
|
||||
export interface GenerationDeps {
|
||||
store: MeetingDocumentStore
|
||||
provider: MeetingDocumentProvider
|
||||
now: () => number
|
||||
log: GenerationLogger
|
||||
}
|
||||
|
||||
export const PROVIDER_MAX_TOKENS = 4096
|
||||
|
||||
function isRecord(value: unknown): value is Record<string, unknown> {
|
||||
return typeof value === 'object' && value !== null && !Array.isArray(value)
|
||||
}
|
||||
|
||||
function result(status: number, body: Record<string, unknown>): GenerationHttpResult {
|
||||
return { status, body }
|
||||
}
|
||||
|
||||
export function parseClaim(value: unknown): ClaimResult | null {
|
||||
if (!isRecord(value)) return null
|
||||
if (
|
||||
typeof value.claimed !== 'boolean'
|
||||
|| !['processing', 'succeeded', 'failed'].includes(String(value.status))
|
||||
|| (value.documentId !== null && typeof value.documentId !== 'string')
|
||||
|| typeof value.meetingTitle !== 'string'
|
||||
|| typeof value.documentTitle !== 'string'
|
||||
|| typeof value.templateType !== 'string'
|
||||
|| (value.systemPrompt !== null && typeof value.systemPrompt !== 'string')
|
||||
|| (value.transcript !== null && typeof value.transcript !== 'string')
|
||||
|| typeof value.model !== 'string'
|
||||
) {
|
||||
return null
|
||||
}
|
||||
return value as unknown as ClaimResult
|
||||
}
|
||||
|
||||
export function isQuotaExceeded(error: DatabaseError | null): boolean {
|
||||
return error?.message?.includes('generation_quota_exceeded') === true
|
||||
}
|
||||
|
||||
export function mapDatabaseError(error: DatabaseError | null, log: GenerationLogger): GenerationHttpResult {
|
||||
const code = error?.code ?? ''
|
||||
if (code === '42501') return result(403, { error: 'forbidden' })
|
||||
if (code === 'P0002') return result(404, { error: 'not_found' })
|
||||
if (code === '22023') return result(400, { error: 'invalid_request' })
|
||||
if (isQuotaExceeded(error)) return result(429, { error: 'quota_exceeded' })
|
||||
log('meeting document database operation failed', { code: code || 'unknown' })
|
||||
return result(500, { error: 'internal_error' })
|
||||
}
|
||||
|
||||
export function buildProviderRequest(
|
||||
claim: ClaimResult & { systemPrompt: string; transcript: string },
|
||||
): ProviderRequest {
|
||||
return {
|
||||
model: claim.model,
|
||||
max_tokens: PROVIDER_MAX_TOKENS,
|
||||
system: buildMeetingDocumentSystemPrompt(claim.systemPrompt),
|
||||
messages: [{
|
||||
role: 'user',
|
||||
content: `회의 제목: ${claim.meetingTitle}\n\n전사록:\n${claim.transcript}`,
|
||||
}],
|
||||
stream: false,
|
||||
}
|
||||
}
|
||||
|
||||
async function replayClaim(
|
||||
actorId: string,
|
||||
claim: ClaimResult,
|
||||
deps: GenerationDeps,
|
||||
): Promise<GenerationHttpResult> {
|
||||
if (claim.status === 'succeeded' && claim.documentId !== null) {
|
||||
const { data: document, error } = await deps.store.findDocument(actorId, claim.documentId)
|
||||
if (error !== null || document === null || document === undefined) {
|
||||
deps.log('idempotent meeting document lookup failed', { code: error?.code ?? 'missing' })
|
||||
return result(500, { error: 'internal_error' })
|
||||
}
|
||||
return result(200, { document, idempotent: true })
|
||||
}
|
||||
return result(409, {
|
||||
error: claim.status === 'processing' ? 'generation_in_progress' : 'generation_failed',
|
||||
})
|
||||
}
|
||||
|
||||
async function runClaimedGeneration(
|
||||
actorId: string,
|
||||
request: GenerateMeetingDocumentRequest,
|
||||
claim: ClaimResult & { systemPrompt: string; transcript: string },
|
||||
deps: GenerationDeps,
|
||||
markFailed: (code: GenerationFailureCode) => Promise<void>,
|
||||
): Promise<GenerationHttpResult> {
|
||||
const startedAt = deps.now()
|
||||
const outcome = await deps.provider.generate(buildProviderRequest(claim))
|
||||
|
||||
if (outcome.kind === 'timeout') {
|
||||
await markFailed('provider_timeout')
|
||||
return result(504, { error: 'provider_timeout' })
|
||||
}
|
||||
if (outcome.kind === 'network_error') {
|
||||
await markFailed('provider_request_failed')
|
||||
return result(502, { error: 'provider_request_failed' })
|
||||
}
|
||||
if (outcome.kind === 'http_error') {
|
||||
deps.log('meeting document provider request failed', { status: outcome.status })
|
||||
await markFailed('provider_request_failed')
|
||||
return result(502, { error: 'provider_request_failed' })
|
||||
}
|
||||
|
||||
const providerResult = parseProviderDocumentResult(outcome.body)
|
||||
if (providerResult === null) {
|
||||
deps.log('meeting document provider returned an invalid response shape')
|
||||
await markFailed('provider_invalid_response')
|
||||
return result(502, { error: 'provider_invalid_response' })
|
||||
}
|
||||
|
||||
const { data: commitData, error: commitError } = await deps.store.commit(
|
||||
actorId,
|
||||
request.idempotencyKey,
|
||||
providerResult,
|
||||
Math.max(0, deps.now() - startedAt),
|
||||
)
|
||||
if (commitError !== null) {
|
||||
const quotaExceeded = isQuotaExceeded(commitError)
|
||||
await markFailed(quotaExceeded ? 'quota_exceeded' : 'commit_failed')
|
||||
if (quotaExceeded) return result(429, { error: 'quota_exceeded' })
|
||||
deps.log('meeting document atomic commit failed', { code: commitError.code ?? 'unknown' })
|
||||
return result(500, { error: 'commit_failed' })
|
||||
}
|
||||
if (!isRecord(commitData) || !isRecord(commitData.document)) {
|
||||
deps.log('meeting document commit returned an invalid shape')
|
||||
return result(500, { error: 'internal_error' })
|
||||
}
|
||||
|
||||
return result(200, {
|
||||
document: commitData.document,
|
||||
idempotent: commitData.idempotent === true,
|
||||
})
|
||||
}
|
||||
|
||||
/**
|
||||
* Claims the request, calls the provider and commits the document.
|
||||
* Throws only for unexpected adapter failures; a claimed request is marked
|
||||
* failed before such an error propagates, so its quota unit is released.
|
||||
*/
|
||||
export async function generateMeetingDocument(
|
||||
actorId: string,
|
||||
request: GenerateMeetingDocumentRequest,
|
||||
deps: GenerationDeps,
|
||||
): Promise<GenerationHttpResult> {
|
||||
const markFailed = async (code: GenerationFailureCode): Promise<void> => {
|
||||
try {
|
||||
const error = await deps.store.markFailed(actorId, request.idempotencyKey, code)
|
||||
if (error !== null) {
|
||||
deps.log('meeting document failure marker failed', { code: error.code ?? 'unknown' })
|
||||
}
|
||||
} catch {
|
||||
deps.log('meeting document failure marker failed', { code: 'exception' })
|
||||
}
|
||||
}
|
||||
|
||||
const { data: claimData, error: claimError } = await deps.store.claim(actorId, request)
|
||||
if (claimError !== null) return mapDatabaseError(claimError, deps.log)
|
||||
|
||||
const claim = parseClaim(claimData)
|
||||
if (claim === null) {
|
||||
deps.log('meeting document claim returned an invalid shape')
|
||||
return result(500, { error: 'internal_error' })
|
||||
}
|
||||
if (!claim.claimed) return await replayClaim(actorId, claim, deps)
|
||||
|
||||
if (claim.systemPrompt === null || claim.transcript === null) {
|
||||
await markFailed('commit_failed')
|
||||
return result(500, { error: 'internal_error' })
|
||||
}
|
||||
const readyClaim = { ...claim, systemPrompt: claim.systemPrompt, transcript: claim.transcript }
|
||||
|
||||
try {
|
||||
return await runClaimedGeneration(actorId, request, readyClaim, deps, markFailed)
|
||||
} catch (error) {
|
||||
// Release the in-flight quota unit held by this claim; the request is not
|
||||
// going to be committed. A no-op if commit already moved it out of
|
||||
// 'processing'.
|
||||
await markFailed('commit_failed')
|
||||
throw error
|
||||
}
|
||||
}
|
||||
|
|
@ -4,22 +4,19 @@ import { createServiceRoleClient } from '../_shared/quota.ts'
|
|||
import {
|
||||
MeetingDocumentRequestError,
|
||||
parseGenerateMeetingDocumentRequest,
|
||||
parseProviderDocumentResult,
|
||||
} from '../_shared/meeting-document-contract.ts'
|
||||
import { buildMeetingDocumentSystemPrompt } from '../_shared/generative-ai-safety.ts'
|
||||
import { readProviderKey } from '../_shared/provider-key.ts'
|
||||
import {
|
||||
generateMeetingDocument,
|
||||
type GenerationLogger,
|
||||
type MeetingDocumentProvider,
|
||||
type MeetingDocumentStore,
|
||||
type ProviderOutcome,
|
||||
} from './generation.ts'
|
||||
|
||||
interface ClaimResult {
|
||||
claimed: boolean
|
||||
status: 'processing' | 'succeeded' | 'failed'
|
||||
documentId: string | null
|
||||
meetingTitle: string
|
||||
documentTitle: string
|
||||
templateType: string
|
||||
systemPrompt: string | null
|
||||
transcript: string | null
|
||||
model: string
|
||||
}
|
||||
type ServiceClient = ReturnType<typeof createServiceRoleClient>
|
||||
|
||||
const PROVIDER_TIMEOUT_MS = 60_000
|
||||
|
||||
function json(status: number, body: Record<string, unknown>): Response {
|
||||
return new Response(JSON.stringify(body), {
|
||||
|
|
@ -32,39 +29,84 @@ function json(status: number, body: Record<string, unknown>): Response {
|
|||
})
|
||||
}
|
||||
|
||||
function isRecord(value: unknown): value is Record<string, unknown> {
|
||||
return typeof value === 'object' && value !== null && !Array.isArray(value)
|
||||
const logError: GenerationLogger = (message, context) => {
|
||||
if (context === undefined) console.error(message)
|
||||
else console.error(message, context)
|
||||
}
|
||||
|
||||
function parseClaim(value: unknown): ClaimResult | null {
|
||||
if (!isRecord(value)) return null
|
||||
if (
|
||||
typeof value.claimed !== 'boolean'
|
||||
|| !['processing', 'succeeded', 'failed'].includes(String(value.status))
|
||||
|| (value.documentId !== null && typeof value.documentId !== 'string')
|
||||
|| typeof value.meetingTitle !== 'string'
|
||||
|| typeof value.documentTitle !== 'string'
|
||||
|| typeof value.templateType !== 'string'
|
||||
|| (value.systemPrompt !== null && typeof value.systemPrompt !== 'string')
|
||||
|| (value.transcript !== null && typeof value.transcript !== 'string')
|
||||
|| typeof value.model !== 'string'
|
||||
) {
|
||||
return null
|
||||
/** Supabase adapter for the persistence port (service-role RPCs). */
|
||||
function createSupabaseStore(client: ServiceClient): MeetingDocumentStore {
|
||||
return {
|
||||
async claim(actorId, request) {
|
||||
const { data, error } = await client.rpc('claim_meeting_document_generation_v1', {
|
||||
p_actor_id: actorId,
|
||||
p_idempotency_key: request.idempotencyKey,
|
||||
p_meeting_id: request.meetingId,
|
||||
p_template_id: request.templateId,
|
||||
p_title: request.title,
|
||||
p_model: request.model,
|
||||
})
|
||||
return { data, error }
|
||||
},
|
||||
async markFailed(actorId, idempotencyKey, code) {
|
||||
const { error } = await client.rpc('fail_meeting_document_generation_v1', {
|
||||
p_actor_id: actorId,
|
||||
p_idempotency_key: idempotencyKey,
|
||||
p_error_code: code,
|
||||
})
|
||||
return error
|
||||
},
|
||||
async commit(actorId, idempotencyKey, providerResult, latencyMs) {
|
||||
const { data, error } = await client.rpc('commit_meeting_document_generation_v1', {
|
||||
p_actor_id: actorId,
|
||||
p_idempotency_key: idempotencyKey,
|
||||
p_content: providerResult.content,
|
||||
p_latency_ms: latencyMs,
|
||||
p_input_tokens: providerResult.inputTokens,
|
||||
p_output_tokens: providerResult.outputTokens,
|
||||
})
|
||||
return { data, error }
|
||||
},
|
||||
async findDocument(actorId, documentId) {
|
||||
const { data, error } = await client
|
||||
.from('meeting_documents')
|
||||
.select('*')
|
||||
.eq('id', documentId)
|
||||
.eq('user_id', actorId)
|
||||
.maybeSingle()
|
||||
return { data, error }
|
||||
},
|
||||
}
|
||||
return value as unknown as ClaimResult
|
||||
}
|
||||
|
||||
function databaseErrorResponse(error: { code?: string; message?: string } | null): Response {
|
||||
const code = error?.code ?? ''
|
||||
const message = error?.message ?? ''
|
||||
if (code === '42501') return json(403, { error: 'forbidden' })
|
||||
if (code === 'P0002') return json(404, { error: 'not_found' })
|
||||
if (code === '22023') return json(400, { error: 'invalid_request' })
|
||||
if (message.includes('generation_quota_exceeded')) {
|
||||
return json(429, { error: 'quota_exceeded' })
|
||||
/** Anthropic Messages API adapter for the provider port. */
|
||||
function createAnthropicProvider(apiKey: string): MeetingDocumentProvider {
|
||||
return {
|
||||
async generate(payload): Promise<ProviderOutcome> {
|
||||
let response: Response
|
||||
try {
|
||||
response = await fetch('https://api.anthropic.com/v1/messages', {
|
||||
method: 'POST',
|
||||
headers: {
|
||||
'Content-Type': 'application/json',
|
||||
'x-api-key': apiKey,
|
||||
'anthropic-version': '2023-06-01',
|
||||
},
|
||||
body: JSON.stringify(payload),
|
||||
signal: AbortSignal.timeout(PROVIDER_TIMEOUT_MS),
|
||||
})
|
||||
} catch (error) {
|
||||
const timedOut = error instanceof DOMException && error.name === 'TimeoutError'
|
||||
return timedOut ? { kind: 'timeout' } : { kind: 'network_error' }
|
||||
}
|
||||
if (!response.ok) return { kind: 'http_error', status: response.status }
|
||||
try {
|
||||
return { kind: 'ok', body: await response.json() }
|
||||
} catch {
|
||||
return { kind: 'ok', body: null }
|
||||
}
|
||||
},
|
||||
}
|
||||
console.error('meeting document database operation failed', { code: code || 'unknown' })
|
||||
return json(500, { error: 'internal_error' })
|
||||
}
|
||||
|
||||
Deno.serve(async (request: Request) => {
|
||||
|
|
@ -72,30 +114,8 @@ Deno.serve(async (request: Request) => {
|
|||
if (preflight) return preflight
|
||||
if (request.method !== 'POST') return json(405, { error: 'method_not_allowed' })
|
||||
|
||||
let actorId: string | null = null
|
||||
let idempotencyKey: string | null = null
|
||||
const serviceClient = createServiceRoleClient()
|
||||
|
||||
const markFailed = async (errorCode:
|
||||
| 'provider_timeout'
|
||||
| 'provider_request_failed'
|
||||
| 'provider_invalid_response'
|
||||
| 'quota_exceeded'
|
||||
| 'commit_failed'): Promise<void> => {
|
||||
if (actorId === null || idempotencyKey === null) return
|
||||
const { error } = await serviceClient.rpc('fail_meeting_document_generation_v1', {
|
||||
p_actor_id: actorId,
|
||||
p_idempotency_key: idempotencyKey,
|
||||
p_error_code: errorCode,
|
||||
})
|
||||
if (error !== null) {
|
||||
console.error('meeting document failure marker failed', { code: error.code ?? 'unknown' })
|
||||
}
|
||||
}
|
||||
|
||||
try {
|
||||
const actor = await requireUser(request)
|
||||
actorId = actor.id
|
||||
|
||||
let rawBody: unknown
|
||||
try {
|
||||
|
|
@ -104,130 +124,19 @@ Deno.serve(async (request: Request) => {
|
|||
throw new MeetingDocumentRequestError('Invalid JSON body')
|
||||
}
|
||||
const body = parseGenerateMeetingDocumentRequest(rawBody)
|
||||
idempotencyKey = body.idempotencyKey
|
||||
|
||||
const providerKey = readProviderKey('ANTHROPIC_API_KEY')
|
||||
if (providerKey.length === 0) {
|
||||
return json(503, { error: 'provider_unavailable' })
|
||||
}
|
||||
|
||||
const { data: claimData, error: claimError } = await serviceClient.rpc(
|
||||
'claim_meeting_document_generation_v1',
|
||||
{
|
||||
p_actor_id: actor.id,
|
||||
p_idempotency_key: body.idempotencyKey,
|
||||
p_meeting_id: body.meetingId,
|
||||
p_template_id: body.templateId,
|
||||
p_title: body.title,
|
||||
p_model: body.model,
|
||||
},
|
||||
)
|
||||
if (claimError !== null) return databaseErrorResponse(claimError)
|
||||
|
||||
const claim = parseClaim(claimData)
|
||||
if (claim === null) {
|
||||
console.error('meeting document claim returned an invalid shape')
|
||||
return json(500, { error: 'internal_error' })
|
||||
}
|
||||
if (!claim.claimed) {
|
||||
if (claim.status === 'succeeded' && claim.documentId !== null) {
|
||||
const { data: document, error } = await serviceClient
|
||||
.from('meeting_documents')
|
||||
.select('*')
|
||||
.eq('id', claim.documentId)
|
||||
.eq('user_id', actor.id)
|
||||
.maybeSingle()
|
||||
if (error !== null || document === null) {
|
||||
console.error('idempotent meeting document lookup failed', { code: error?.code ?? 'missing' })
|
||||
return json(500, { error: 'internal_error' })
|
||||
}
|
||||
return json(200, { document, idempotent: true })
|
||||
}
|
||||
return json(409, {
|
||||
error: claim.status === 'processing' ? 'generation_in_progress' : 'generation_failed',
|
||||
})
|
||||
}
|
||||
if (claim.systemPrompt === null || claim.transcript === null) {
|
||||
await markFailed('commit_failed')
|
||||
return json(500, { error: 'internal_error' })
|
||||
}
|
||||
|
||||
const startedAt = Date.now()
|
||||
let providerResponse: Response
|
||||
try {
|
||||
providerResponse = await fetch('https://api.anthropic.com/v1/messages', {
|
||||
method: 'POST',
|
||||
headers: {
|
||||
'Content-Type': 'application/json',
|
||||
'x-api-key': providerKey,
|
||||
'anthropic-version': '2023-06-01',
|
||||
},
|
||||
body: JSON.stringify({
|
||||
model: claim.model,
|
||||
max_tokens: 4096,
|
||||
system: buildMeetingDocumentSystemPrompt(claim.systemPrompt),
|
||||
messages: [{
|
||||
role: 'user',
|
||||
content: `회의 제목: ${claim.meetingTitle}\n\n전사록:\n${claim.transcript}`,
|
||||
}],
|
||||
stream: false,
|
||||
}),
|
||||
signal: AbortSignal.timeout(60_000),
|
||||
})
|
||||
} catch (error) {
|
||||
const timedOut = error instanceof DOMException && error.name === 'TimeoutError'
|
||||
await markFailed(timedOut ? 'provider_timeout' : 'provider_request_failed')
|
||||
return json(timedOut ? 504 : 502, {
|
||||
error: timedOut ? 'provider_timeout' : 'provider_request_failed',
|
||||
})
|
||||
}
|
||||
|
||||
if (!providerResponse.ok) {
|
||||
console.error('meeting document provider request failed', { status: providerResponse.status })
|
||||
await markFailed('provider_request_failed')
|
||||
return json(502, { error: 'provider_request_failed' })
|
||||
}
|
||||
|
||||
let providerBody: unknown
|
||||
try {
|
||||
providerBody = await providerResponse.json()
|
||||
} catch {
|
||||
providerBody = null
|
||||
}
|
||||
const providerResult = parseProviderDocumentResult(providerBody)
|
||||
if (providerResult === null) {
|
||||
console.error('meeting document provider returned an invalid response shape')
|
||||
await markFailed('provider_invalid_response')
|
||||
return json(502, { error: 'provider_invalid_response' })
|
||||
}
|
||||
|
||||
const { data: commitData, error: commitError } = await serviceClient.rpc(
|
||||
'commit_meeting_document_generation_v1',
|
||||
{
|
||||
p_actor_id: actor.id,
|
||||
p_idempotency_key: body.idempotencyKey,
|
||||
p_content: providerResult.content,
|
||||
p_latency_ms: Math.max(0, Date.now() - startedAt),
|
||||
p_input_tokens: providerResult.inputTokens,
|
||||
p_output_tokens: providerResult.outputTokens,
|
||||
},
|
||||
)
|
||||
if (commitError !== null) {
|
||||
const quotaExceeded = commitError.message?.includes('generation_quota_exceeded') === true
|
||||
await markFailed(quotaExceeded ? 'quota_exceeded' : 'commit_failed')
|
||||
if (quotaExceeded) return json(429, { error: 'quota_exceeded' })
|
||||
console.error('meeting document atomic commit failed', { code: commitError.code ?? 'unknown' })
|
||||
return json(500, { error: 'commit_failed' })
|
||||
}
|
||||
if (!isRecord(commitData) || !isRecord(commitData.document)) {
|
||||
console.error('meeting document commit returned an invalid shape')
|
||||
return json(500, { error: 'internal_error' })
|
||||
}
|
||||
|
||||
return json(200, {
|
||||
document: commitData.document,
|
||||
idempotent: commitData.idempotent === true,
|
||||
const outcome = await generateMeetingDocument(actor.id, body, {
|
||||
store: createSupabaseStore(createServiceRoleClient()),
|
||||
provider: createAnthropicProvider(providerKey),
|
||||
now: () => Date.now(),
|
||||
log: logError,
|
||||
})
|
||||
return json(outcome.status, outcome.body)
|
||||
} catch (error) {
|
||||
if (error instanceof MeetingDocumentRequestError) {
|
||||
return json(error.status, { error: 'invalid_request', message: error.message })
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue