diff --git a/apps/website/src/components/workshop/WorkflowPlayground.vue b/apps/website/src/components/workshop/WorkflowPlayground.vue index 6e8c2c0f99b..d6ca5ed5f61 100644 --- a/apps/website/src/components/workshop/WorkflowPlayground.vue +++ b/apps/website/src/components/workshop/WorkflowPlayground.vue @@ -17,6 +17,7 @@ import { workflowErrorKey, workflowStatusKey } from '../../config/workshop-workflow-presentation' +import { panelSaysRefusal } from '../../lib/workshop/workflow-refusal' import { useTablist } from '../../composables/useTablist' import { useWorkflowFormDraft } from '../../composables/useWorkflowFormDraft' import { useWorkflowRun } from '../../composables/useWorkflowRun' @@ -125,6 +126,12 @@ const error = computed(() => : undefined ) const fieldErrors = computed(() => error.value?.fieldErrors ?? {}) +// What is left for this page to say is what the panel does not carry. +const refusalSaidHere = computed(() => + error.value && !panelSaysRefusal(state.value) + ? t(workflowErrorKey(error.value)) + : undefined +) const statusLabel = computed(() => { if (cancelRequested.value && busy.value) return t('workshop.workflow.cancelling') @@ -251,8 +258,12 @@ function start() { > {{ t('workshop.workflow.paused') }}

- { expect(f.state.value.phase).toBe('settled') }) }) + +// A request Cloud turns down used to leave the panel showing the example: a +// picture of a successful run, beside a form that had just been refused. +describe('a refused request', () => { + function mountRefused(code: WorkshopWorkflowError['code']) { + const model = workflowDetailsBySlug.get('workflows/remove-background') + assert(model) + render(WorkflowResults, { + props: { + model, + state: { + phase: 'failed', + error: new WorkshopWorkflowError(code) + } satisfies WorkflowState, + exampleIndex: 0, + busy: false, + statusLabel: '', + canStart: true, + refreshOutput: async () => undefined + } + }) + } + + it('stands the refusal up in the output panel instead of the example', () => { + mountRefused('insufficient_credits') + + // Shown and also announced, so the sentence is on the page more than once. + expect( + screen.getAllByText('Not enough credits. Add credits to continue.').length + ).toBeGreaterThan(0) + expect(screen.queryByText('An example from this template.')).toBeNull() + }) + + // The panel already knows how to send a reader to buy credits; it was never + // being told that was the refusal. A button that reaches nothing is not a way + // out, so press it and watch for the request the page answers. + it('offers the way out the refusal has', async () => { + const asked = vi.fn() + onTestFinished(subscribeToWorkshopBuyCredits(asked)) + mountRefused('insufficient_credits') + + await userEvent + .setup() + .click(screen.getByRole('button', { name: /credits/i })) + expect(asked).toHaveBeenCalledOnce() + }) + + // A refusal the panel has no sentence for is said beside the form instead. + // The panel then shows nothing — not the example, which is a picture of a run + // that worked. + it('shows nothing rather than the example for a refusal it cannot word', () => { + mountRefused('access_denied') + + expect(screen.queryByText('An example from this template.')).toBeNull() + expect(screen.getByText('Your output will appear here.')).toBeTruthy() + }) +}) diff --git a/apps/website/src/components/workshop/WorkflowResults.vue b/apps/website/src/components/workshop/WorkflowResults.vue index fbf29dae9fe..d33df9159ae 100644 --- a/apps/website/src/components/workshop/WorkflowResults.vue +++ b/apps/website/src/components/workshop/WorkflowResults.vue @@ -9,6 +9,8 @@ import { useWorkshopDelivery } from '../../composables/useWorkshopDelivery' import type { WorkflowState } from '../../config/workshop-workflow-state' import { workflowOutputs } from '../../config/workshop-workflow-response' import { outputLabels } from '../../lib/workshop/output-labels' +import { requestWorkshopBuyCredits } from '../../config/workshop-buy-credits' +import { workflowRunFailure } from '../../lib/workshop/workflow-refusal' import { t } from '../../i18n/translations' import { captureWorkshopEvent } from '../../scripts/posthog' import type { WorkshopRunAnalytics } from '../../scripts/workshop-analytics' @@ -53,19 +55,43 @@ const runningState = computed(() => ({ const outputs = computed(() => observation.value ? workflowOutputs(observation.value) : [] ) -const outputState = computed(() => { +// What Cloud last said about a run it accepted. Undefined while it has said +// nothing the panel can draw yet, including a finished run whose outputs have +// not arrived. +const observedState = computed(() => { const result = observation.value - if (result?.run.state === 'succeeded' && outputs.value[0]) { - return { - status: 'succeeded', - output: outputs.value[0], - nsfw: false, - completedAt: Date.parse(result.run.completedAt ?? result.run.updatedAt) - } - } - if (result?.run.state === 'cancelled') return { status: 'idle' } - if (result?.run.state === 'failed') + if (!result) return undefined + const output = outputs.value[0] + if (result.run.state === 'succeeded') + return output + ? { + status: 'succeeded', + output, + nsfw: false, + completedAt: Date.parse( + result.run.completedAt ?? result.run.updatedAt + ) + } + : undefined + if (result.run.state === 'cancelled') return { status: 'idle' } + if (result.run.state === 'failed') return { status: 'failed', reason: 'provider', fieldErrors: {} } + return undefined +}) +// A request Cloud turned down used to fall through to the example, so the panel +// showed what the workflow makes while the run had just been refused. Where the +// panel has the words for it, it says so; where it does not, the page says it +// beside the form and the panel shows nothing, because nothing was made. +const refusedState = computed(() => { + if (state.phase !== 'failed') return undefined + const reason = workflowRunFailure(state.error) + return reason + ? { status: 'failed', reason, fieldErrors: state.error.fieldErrors } + : { status: 'idle' } +}) +const outputState = computed(() => { + if (observedState.value) return observedState.value + if (refusedState.value) return refusedState.value if (busy) return runningState.value if (state.phase === 'settled') return { status: 'idle' } return exampleState.value @@ -185,6 +211,7 @@ function captureDownload(kind: RunOutput['kind']) { :retry-disabled="!canStart" refreshable @retry="emit('retry')" + @buy-credits="requestWorkshopBuyCredits" @refresh="refreshUrl" @delivery="onDelivery" @playback-started="delivery.beginPlayback" diff --git a/apps/website/src/lib/workshop/workflow-refusal.test.ts b/apps/website/src/lib/workshop/workflow-refusal.test.ts new file mode 100644 index 00000000000..387216d44b8 --- /dev/null +++ b/apps/website/src/lib/workshop/workflow-refusal.test.ts @@ -0,0 +1,154 @@ +import { describe, expect, it } from 'vitest' + +import { WorkshopWorkflowError } from '../../config/workshop-workflow-api' +import type { RunFailure } from '../../config/workshop-run' +import type { + WorkflowErrorCode, + WorkflowRun, + WorkflowRunSummary +} from '../../config/workshop-workflow-response' +import type { WorkflowState } from '../../config/workshop-workflow-state' +import type { SavedWorkflow } from '../../config/workshop-workflow-storage' +import { failureLabelKey } from './failure-label' +import { panelSaysRefusal, workflowRunFailure } from './workflow-refusal' + +// Every code the API can report and the refusal the panel stands up for it. The +// table is the specification: a code whose event the panel has no sentence for +// reads as undefined here, rather than as a sentence about something else. +const REFUSALS: readonly [ + WorkflowErrorCode | 'network' | 'response' | 'persistence', + RunFailure | undefined +][] = [ + ['insufficient_credits', 'noCredits'], + ['rate_limited', 'rateLimit'], + ['network', 'network'], + ['response', 'response'], + ['execution_failed', 'provider'], + // What is wrong with an input belongs beside the input, and the panel's own + // words for a rejection it cannot pin to a field are about a model. + ['invalid_request', undefined], + ['invalid_input', undefined], + ['payload_too_large', undefined], + ['unsupported_media_type', undefined], + // A session that expired and a form gone out of date the panel has no word + // for at all. + ['not_authenticated', undefined], + ['workflow_not_found', undefined], + ['definition_changed', undefined], + ['definition_incompatible', undefined], + // Codes the panel has a word for, about a different event: a workspace Cloud + // denied is not a provider's content policy; an input upload that never + // arrived is not a model being down; outputs that could not be fetched after + // a run finished is not a connection that dropped mid-run; browser storage + // the page could not write names its own fix, which the panel's sentence + // does not. + ['access_denied', undefined], + ['media_unavailable', undefined], + ['delivery_failed', undefined], + ['submission_unknown', undefined], + ['persistence', undefined], + ['run_not_found', undefined] +] + +describe('workflowRunFailure', () => { + it.for(REFUSALS)('stands %s up as %s', ([code, refusal]) => { + expect(workflowRunFailure({ code })).toBe(refusal) + }) + + // A code this page has not met yet is not given a sentence about something + // else; the page keeps saying what it says today. 'toString' is here because + // a plain object would have answered it with a method of its prototype. + it.for(['teapot', 'toString', 'constructor'] as const)( + 'claims nothing about %s, a code it does not know', + (code) => { + expect( + workflowRunFailure({ code: code as WorkflowErrorCode }) + ).toBeUndefined() + } + ) + + it('only ever names a refusal the panel has words for', () => { + for (const [, refusal] of REFUSALS) + if (refusal) expect(failureLabelKey[refusal]).toBeTruthy() + }) +}) + +// Whether the page keeps quiet beside the form follows from the same table: it +// speaks exactly where the panel does not, so the reader is never handed the +// same refusal twice, nor two different accounts of it. +describe('panelSaysRefusal', () => { + it.for(REFUSALS)('leaves %s to the panel only as %s', ([code, refusal]) => { + expect( + panelSaysRefusal({ + phase: 'failed', + error: new WorkshopWorkflowError(code) + }) + ).toBe(refusal !== undefined) + }) + + it.for([{ phase: 'idle' }, { phase: 'preparing' }] as const)( + 'says nothing about a $phase page', + (state) => { + expect(panelSaysRefusal(state)).toBe(false) + } + ) + + // A run Cloud accepted and then reported failed is the panel's to say, and it + // says it as a provider failure. The page used to add a second sentence of its + // own here — in different words, telling the reader to change the inputs the + // panel had just told them to leave alone. + it.for([ + { reported: 'failed', panel: true }, + { reported: 'succeeded', panel: false }, + { reported: 'cancelled', panel: false } + ] as const)( + 'leaves a run reported $reported to the panel: $panel', + ({ reported, panel }) => { + expect(panelSaysRefusal(observed(reported))).toBe(panel) + } + ) + + // A dropped connection is the one state that carries both: what Cloud last + // said about the run, and the error that dropped it. The run wins. Reading the + // error first would hand this back to the page, which has a second sentence + // ready for a code the panel cannot name. + it('leaves a failed run to the panel when the connection dropped on a code it has no words for', () => { + expect( + panelSaysRefusal({ + phase: 'interrupted', + record: RECORD, + observation: run('failed'), + error: new WorkshopWorkflowError('media_unavailable') + }) + ).toBe(true) + }) +}) + +const RECORD: SavedWorkflow = { + version: 2, + cancelRequested: false, + stage: 'run', + runId: 'run', + workflowId: 'workflow', + definitionVersion: '1' +} + +function run(state: WorkflowRunSummary['state']): WorkflowRun { + const stamp = new Date(0).toISOString() + return { + run: { + id: 'run', + workflowId: 'workflow', + definitionVersion: '1', + state, + outputState: 'ready', + createdAt: stamp, + updatedAt: stamp + }, + outputs: [] + } +} + +function observed(state: WorkflowRunSummary['state']): WorkflowState { + return { phase: 'settled', record: RECORD, observation: run(state) } +} diff --git a/apps/website/src/lib/workshop/workflow-refusal.ts b/apps/website/src/lib/workshop/workflow-refusal.ts new file mode 100644 index 00000000000..5b15da63590 --- /dev/null +++ b/apps/website/src/lib/workshop/workflow-refusal.ts @@ -0,0 +1,58 @@ +import type { WorkshopWorkflowError } from '../../config/workshop-workflow-api' +import type { RunFailure } from '../../config/workshop-run' +import type { WorkflowState } from '../../config/workshop-workflow-state' + +/** + * Which refusal the output panel should stand up, where the panel's own words + * are about the same event as this page's. + * + * The two halves of the Hub refuse things in different vocabularies, and a + * shared word is not a shared meaning: Cloud denying a workspace is not a + * provider's content policy, and an input upload that never arrived is not a + * model being down. So a code reaches the panel only where the sentence the + * panel already has says what actually happened; everywhere else the page's + * own accurate sentence stays beside the form, and the panel shows nothing + * rather than either the wrong words or a picture of a run that succeeded. + */ +export function workflowRunFailure( + error: Pick +): RunFailure | undefined { + return REFUSALS.get(error.code) +} + +// A Map, not an object: a code the page has never met must read as absent, and +// an object would hand back whatever Object.prototype happens to call by that +// name — 'toString' would arrive as a refusal. +const REFUSALS = new Map([ + // The same sentence in both, and the only way out of it — Add credits, or + // the reader's own workspace — is the panel's to offer. + ['insufficient_credits', 'noCredits'], + // The same sentence in both. + ['rate_limited', 'rateLimit'], + // Both about a connection that went while a run may be alive and billed. + ['network', 'network'], + // A response that arrived and could not be read, which is what this page + // otherwise reports only as a run it could not check. + ['response', 'response'], + // One event, and the panel says more of it: the credits that may have gone + // without a result, and the request ID to quote. + ['execution_failed', 'provider'] +]) + +/** + * Whether the output panel is the one saying this failure. The page then keeps + * quiet beside the form rather than handing the reader the same thing twice — + * and twice in different words wherever the two vocabularies disagree. + * + * A run Cloud reports as failed is always the panel's: it stands that up as a + * provider failure regardless of what the page made of the request. Only a + * request Cloud turned down depends on whether the panel has words for the + * code. + */ +export function panelSaysRefusal(state: WorkflowState): boolean { + if ('observation' in state && state.observation?.run.state === 'failed') + return true + return ( + state.phase === 'failed' && workflowRunFailure(state.error) !== undefined + ) +}