@namzu/sdk 3.1.0 → 3.2.0

package/src/runtime/query/iteration/phases/compaction-model-routing.test.ts

@@ -0,0 +1,125 @@
+import { describe, expect, it, vi } from 'vitest'
+
+import { WorkingStateManager } from '../../../../compaction/manager.js'
+import { CompactionConfigSchema } from '../../../../config/runtime.js'
+import type { CompactionConfig } from '../../../../config/runtime.js'
+import type { Message } from '../../../../types/message/index.js'
+import type { TaskRouterConfig } from '../../../../types/router/index.js'
+import { runCompactionCheck } from './compaction.js'
+import type { IterationContext } from './context.js'
+
+/**
+ * The compaction summary is the only model call a run makes that nobody
+ * asked for, and it was hardwired to the primary model. `taskRouter` had been
+ * accepted, schema-validated and threaded through four types since it was
+ * added, with `resolveTaskModel` exported and never called — so a host who
+ * pointed compaction at a cheap model kept paying the expensive one.
+ */
+
+function harness(taskRouter?: TaskRouterConfig): {
+	ctx: IterationContext
+	modelsUsed: string[]
+} {
+	const messages: Message[] = [
+		{ role: 'system', content: 'prompt', timestamp: 1 },
+		...Array.from({ length: 40 }, (_, i) => ({
+			role: 'user' as const,
+			content: `turn ${i} `.repeat(200),
+			timestamp: 1,
+		})),
+	]
+	const config: CompactionConfig = {
+		...CompactionConfigSchema.parse({}),
+		contextWindowTokens: 1_000,
+		keepRecentMessages: 4,
+		llmVerification: true,
+		// Keep the slot count under the rich-state threshold so the verified
+		// summary path — the one that calls a model — is the one taken.
+		richStateThreshold: 1_000,
+	}
+	const modelsUsed: string[] = []
+
+	const ctx = {
+		compactionConfig: config,
+		workingStateManager: new WorkingStateManager(config),
+		runConfig: { model: 'primary-model' },
+		...(taskRouter ? { taskRouter } : {}),
+		runMgr: {
+			id: 'run_routing',
+			messages,
+			accumulateUsage: vi.fn(),
+			clearLastPromptTokens: vi.fn(),
+		},
+		provider: {
+			chatStream: async function* (params: { model: string }) {
+				modelsUsed.push(params.model)
+				yield { id: 'c1', delta: { content: 'a summary' } }
+				yield {
+					id: 'c1',
+					delta: {},
+					finishReason: 'stop',
+					usage: { promptTokens: 1, completionTokens: 1, totalTokens: 2 },
+				}
+			},
+		},
+		log: { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() },
+	} as unknown as IterationContext
+
+	return { ctx, modelsUsed }
+}
+
+describe('the compaction summary goes to the model a host routed it to', () => {
+	it('uses the primary model when nothing is routed', async () => {
+		const h = harness()
+
+		await runCompactionCheck(h.ctx)
+
+		expect(h.modelsUsed).toEqual(['primary-model'])
+	})
+
+	it('uses the compaction model when one is named', async () => {
+		const h = harness({ compaction: 'small-model' })
+
+		await runCompactionCheck(h.ctx)
+
+		expect(h.modelsUsed).toEqual(['small-model'])
+	})
+
+	it('falls back to the router default', async () => {
+		const h = harness({ default: 'fallback-model' })
+
+		await runCompactionCheck(h.ctx)
+
+		expect(h.modelsUsed).toEqual(['fallback-model'])
+	})
+
+	it('prefers the specific key over the default', async () => {
+		const h = harness({ compaction: 'small-model', default: 'fallback-model' })
+
+		await runCompactionCheck(h.ctx)
+
+		expect(h.modelsUsed).toEqual(['small-model'])
+	})
+
+	it('ignores a key that names no model', async () => {
+		// `null` is what the schema produces for an explicitly cleared key, and
+		// it has to mean "unrouted" rather than "route to nothing" — sending an
+		// empty model id is an endpoint error on backends where the id IS the
+		// endpoint.
+		const h = harness({ compaction: null, default: 'fallback-model' })
+
+		await runCompactionCheck(h.ctx)
+
+		expect(h.modelsUsed).toEqual(['fallback-model'])
+	})
+
+	it('does not route a key the runtime does not consult', async () => {
+		// `coding` is documented as inert. Pinning that keeps the docs honest:
+		// if a future change starts consulting it, this test says so.
+		const h = harness({ coding: 'coding-model' })
+
+		await runCompactionCheck(h.ctx)
+
+		expect(h.modelsUsed).toEqual(['primary-model'])
+	})
+})

package/src/runtime/query/iteration/phases/compaction.ts

@@ -1,10 +1,13 @@
 import { resolveContextWindow } from '../../../../compaction/context-window.js'
-import { findSafeTrimIndex } from '../../../../compaction/dangling.js'
+import { findDanglingMessages, findSafeTrimIndex } from '../../../../compaction/dangling.js'
+import type { ContextReducer, ContextReduction } from '../../../../compaction/reducer.js'
+import { createSlidingWindowReducer } from '../../../../compaction/reducer.js'
 import { findRetainedIndices } from '../../../../compaction/retention.js'
 import { serializeState } from '../../../../compaction/serializer.js'
 import { clearStaleToolResults } from '../../../../compaction/tool-result-editing.js'
 import { buildVerifiedSummary } from '../../../../compaction/verifier.js'
 import { CHARS_PER_TOKEN } from '../../../../constants/limits.js'
+import { resolveTaskModel } from '../../../../router/task-router.js'
 import type { Message } from '../../../../types/message/index.js'
 import { createSystemMessage } from '../../../../types/message/index.js'
 import type { IterationContext } from './context.js'
@@ -202,6 +205,78 @@ function totalChars(messages: readonly { content: unknown }[]): number {
 	return total
 }
 
+/**
+ * Run a reducer and install what it returns, or leave the history alone.
+ *
+ * Three ways to decline, all of them ending the same way — the run keeps its
+ * full history. `undefined` is the reducer saying so; a throw is treated as
+ * the same answer, because a broken reduction hook should not kill a healthy
+ * run any more than a broken `prepareStep` should; and a result that splits a
+ * tool pair is REFUSED rather than repaired.
+ *
+ * That last one is the least obvious and the most important. `tool_result`
+ * without its `tool_use` is a provider 400 on the next turn, so quietly
+ * repairing it would trade a clear "this reducer split a tool pair" for an
+ * opaque rejection a call later, with the reducer never implicated. The
+ * invariant is written on {@link ContextReducer}; enforcing it where it is
+ * violated is what makes it true rather than aspirational.
+ */
+async function applyReducer(
+	ctx: IterationContext,
+	reducer: ContextReducer,
+	reduction: ContextReduction,
+): Promise<void> {
+	const messages = ctx.runMgr.messages
+	const before = messages.length
+	const beforeChars = totalChars(messages)
+
+	let next: readonly Message[] | undefined
+	try {
+		next = await reducer(reduction)
+	} catch (error) {
+		ctx.log.warn('Context reducer threw — keeping the full history', {
+			runId: ctx.runMgr.id,
+			reason: reduction.reason,
+			error: error instanceof Error ? error.message : String(error),
+		})
+		return
+	}
+
+	if (!next || next.length >= before) {
+		ctx.log.debug('Context reducer shed nothing', {
+			runId: ctx.runMgr.id,
+			reason: reduction.reason,
+			messages: before,
+		})
+		return
+	}
+
+	if (!findDanglingMessages([...next]).isValid) {
+		ctx.log.warn('Context reducer split a tool pair — refusing its result', {
+			runId: ctx.runMgr.id,
+			reason: reduction.reason,
+			hint: 'use findSafeTrimIndex to move a cut off a tool_use/tool_result boundary',
+		})
+		return
+	}
+
+	messages.length = 0
+	for (const message of next) messages.push(message)
+
+	// The provider's count described the pre-reduction prompt. Same reasoning
+	// as the structured path: leaving it would have the next trigger check
+	// compare an old size against the new history and reduce again.
+	ctx.runMgr.clearLastPromptTokens?.()
+
+	ctx.log.info('Context reduced', {
+		runId: ctx.runMgr.id,
+		reason: reduction.reason,
+		oldMessageCount: before,
+		newMessageCount: messages.length,
+		charsShed: beforeChars - totalChars(messages),
+	})
+}
+
 export async function runCompactionCheck(
 	ctx: IterationContext,
 	options?: { force?: boolean },
@@ -210,9 +285,6 @@ export async function runCompactionCheck(
 	if (!config) return
 	if (config.strategy === 'disabled') return
 
-	const manager = ctx.workingStateManager
-	if (!manager) return
-
 	const measured = measureContext(ctx)
 	const estimatedTokens = measured.tokens
 
@@ -232,6 +304,29 @@ export async function runCompactionCheck(
 	// rejected the prompt, which is stronger evidence than any estimate.
 	if (!options?.force && usage < config.triggerThreshold) return
 
+	// A reducer, when the run has one, OWNS reduction — the structured pass
+	// below does not also run. `strategy: 'sliding-window'` resolves to the
+	// built-in one; a host-supplied reducer outranks the strategy entirely,
+	// because someone who wrote a reducer has said what they want more
+	// specifically than an enum can.
+	const reducer =
+		ctx.contextReducer ??
+		(config.strategy === 'sliding-window' ? createSlidingWindowReducer() : undefined)
+	if (reducer) {
+		await applyReducer(ctx, reducer, {
+			messages: ctx.runMgr.messages,
+			reason: options?.force ? 'overflow' : 'threshold',
+			estimatedTokens,
+			contextWindowTokens: budget,
+			model: ctx.runConfig.model,
+			keepRecentMessages: config.keepRecentMessages,
+		})
+		return
+	}
+
+	const manager = ctx.workingStateManager
+	if (!manager) return
+
 	ctx.log.info('Compaction threshold reached — compacting context', {
 		runId: ctx.runMgr.id,
 		contextTokens: estimatedTokens,
@@ -380,7 +475,13 @@ export async function runCompactionCheck(
 			ctx.provider,
 			config,
 			(usage) => ctx.runMgr.accumulateUsage(usage),
-			ctx.runConfig.model,
+			// The one model call a run makes that the user never asked for. It
+			// reads a transcript and writes a summary, which is the cheapest
+			// thing a small model does well, and it fires on exactly the long
+			// runs where the primary model is most expensive. `taskRouter` had
+			// been accepted, validated and threaded through four types since it
+			// was added, and nothing ever consulted it.
+			resolveTaskModel('compaction', ctx.taskRouter, ctx.runConfig.model),
 		)
 	} else {
 		compactedContent = serializeState(manager.getState())

package/src/runtime/query/iteration/phases/context-reducer-dispatch.test.ts

@@ -0,0 +1,238 @@
+import { describe, expect, it, vi } from 'vitest'
+
+import { WorkingStateManager } from '../../../../compaction/manager.js'
+import type { ContextReducer } from '../../../../compaction/reducer.js'
+import { CompactionConfigSchema } from '../../../../config/runtime.js'
+import type { CompactionConfig } from '../../../../config/runtime.js'
+import type { Message } from '../../../../types/message/index.js'
+import { runCompactionCheck } from './compaction.js'
+import type { IterationContext } from './context.js'
+
+/**
+ * `strategy` had three values and two behaviours.
+ *
+ * The runtime asked only `strategy !== 'disabled'`, so `'sliding-window'` —
+ * the name a host picks precisely to AVOID paying for summarization — ran the
+ * full structured pass, model call included. These tests are about the
+ * dispatch rather than the algorithms: that choosing a strategy selects one,
+ * that a host-supplied reducer outranks the enum, and that the structured
+ * pass does not also run when something else owns reduction.
+ */
+
+const sys = (content: string): Message => ({ role: 'system', content, timestamp: 1 })
+const user = (content: string): Message => ({ role: 'user', content, timestamp: 1 })
+
+function longHistory(): Message[] {
+	// Long enough to be over any threshold once the window is small.
+	return [sys('prompt'), ...Array.from({ length: 40 }, (_, i) => user(`turn ${i} `.repeat(200)))]
+}
+
+interface Harness {
+	readonly ctx: IterationContext
+	readonly messages: Message[]
+	readonly providerCalls: () => number
+	readonly warnings: string[]
+}
+
+function harness(
+	over: Partial<IterationContext> & { compaction?: Partial<CompactionConfig> },
+): Harness {
+	const messages = longHistory()
+	const config: CompactionConfig = {
+		...CompactionConfigSchema.parse({}),
+		// A tiny window puts the run over the trigger immediately.
+		contextWindowTokens: 1_000,
+		keepRecentMessages: 4,
+		...over.compaction,
+	}
+	const warnings: string[] = []
+	let providerCalls = 0
+
+	const ctx = {
+		compactionConfig: config,
+		workingStateManager: new WorkingStateManager(config),
+		runConfig: { model: 'mock-model' },
+		runMgr: {
+			id: 'run_dispatch',
+			messages,
+			accumulateUsage: vi.fn(),
+			clearLastPromptTokens: vi.fn(),
+		},
+		provider: {
+			// The structured path's only observable side effect that a reducer
+			// path must not have: it pays for a summary.
+			chat: async () => {
+				providerCalls++
+				return { content: 'summary', usage: { promptTokens: 1, completionTokens: 1 } }
+			},
+		},
+		log: {
+			debug: vi.fn(),
+			info: vi.fn(),
+			warn: (message: string) => warnings.push(message),
+			error: vi.fn(),
+		},
+		...over,
+	} as unknown as IterationContext
+
+	return { ctx, messages, providerCalls: () => providerCalls, warnings }
+}
+
+describe('choosing a strategy selects one', () => {
+	it("'sliding-window' trims and summarizes nothing", async () => {
+		const h = harness({ compaction: { strategy: 'sliding-window', llmVerification: true } })
+
+		await runCompactionCheck(h.ctx)
+
+		expect(h.messages.length).toBeLessThan(41)
+		// The whole reason a host names this strategy.
+		expect(h.providerCalls()).toBe(0)
+		// Every survivor is verbatim — no `[COMPACTED CONTEXT]` block appears.
+		expect(h.messages.some((m) => String(m.content).includes('COMPACTED CONTEXT'))).toBe(false)
+	})
+
+	it("'structured' still summarizes", async () => {
+		const h = harness({ compaction: { strategy: 'structured', llmVerification: false } })
+
+		await runCompactionCheck(h.ctx)
+
+		expect(h.messages.some((m) => String(m.content).includes('COMPACTED CONTEXT'))).toBe(true)
+	})
+
+	it("'disabled' leaves the history alone", async () => {
+		const h = harness({ compaction: { strategy: 'disabled' } })
+
+		await runCompactionCheck(h.ctx)
+
+		expect(h.messages.length).toBe(41)
+	})
+})
+
+describe('a host reducer outranks the enum', () => {
+	it('runs instead of the structured pass', async () => {
+		// Deliberately NOT a tiny slice: leave more than the structured pass
+		// needs to act, so "the reducer ran" and "only the reducer ran" are
+		// different observations.
+		const reduce: ContextReducer = ({ messages }) => messages.slice(0, 20)
+		const h = harness({ contextReducer: reduce, compaction: { strategy: 'structured' } })
+
+		await runCompactionCheck(h.ctx)
+
+		expect(h.messages.length).toBe(20)
+		expect(h.messages.some((m) => String(m.content).includes('COMPACTED CONTEXT'))).toBe(false)
+	})
+
+	it('is told whether the provider already rejected the prompt', async () => {
+		const seen: string[] = []
+		const reduce: ContextReducer = ({ messages, reason }) => {
+			seen.push(reason)
+			return messages.slice(0, 5)
+		}
+		const h = harness({ contextReducer: reduce })
+
+		await runCompactionCheck(h.ctx)
+		await runCompactionCheck(h.ctx, { force: true })
+
+		expect(seen).toEqual(['threshold', 'overflow'])
+	})
+
+	it('may be async, so a reducer can call a model of its own', async () => {
+		const reduce: ContextReducer = async ({ messages }) => {
+			await Promise.resolve()
+			return messages.slice(0, 3)
+		}
+		const h = harness({ contextReducer: reduce })
+
+		await runCompactionCheck(h.ctx)
+
+		expect(h.messages.length).toBe(3)
+	})
+
+	it('gets the window it has to fit, not the run token budget', async () => {
+		let saw = 0
+		const reduce: ContextReducer = ({ contextWindowTokens, messages }) => {
+			saw = contextWindowTokens
+			return messages.slice(0, 5)
+		}
+		const h = harness({ contextReducer: reduce, compaction: { contextWindowTokens: 12_345 } })
+
+		await runCompactionCheck(h.ctx)
+
+		expect(saw).toBe(12_345)
+	})
+})
+
+describe('a reducer that cannot be trusted is not obeyed', () => {
+	it('keeps the full history when the reducer throws', async () => {
+		const reduce: ContextReducer = () => {
+			throw new Error('boom')
+		}
+		const h = harness({ contextReducer: reduce })
+
+		await runCompactionCheck(h.ctx)
+
+		// Fail open: a broken reduction hook should not take down a healthy run,
+		// the same way a broken `prepareStep` does not.
+		expect(h.messages.length).toBe(41)
+		expect(h.warnings.some((w) => w.includes('threw'))).toBe(true)
+	})
+
+	it('refuses a result that orphans a tool result', async () => {
+		const h = harness({
+			contextReducer: ({ messages }) => [
+				messages[0] as Message,
+				{ role: 'tool', content: 'ok', timestamp: 1, toolCallId: 'nobody' } as Message,
+			],
+		})
+
+		await runCompactionCheck(h.ctx)
+
+		// Installing this would trade a nameable "your reducer split a tool
+		// pair" for an opaque provider rejection a call later.
+		expect(h.messages.length).toBe(41)
+		expect(h.warnings.some((w) => w.includes('split a tool pair'))).toBe(true)
+	})
+
+	it('ignores a reducer that returns the history unchanged', async () => {
+		const h = harness({ contextReducer: ({ messages }) => messages })
+
+		await runCompactionCheck(h.ctx)
+
+		expect(h.messages.length).toBe(41)
+	})
+
+	it('leaves the history alone when the reducer declines', async () => {
+		const h = harness({ contextReducer: () => undefined })
+
+		await runCompactionCheck(h.ctx)
+
+		expect(h.messages.length).toBe(41)
+	})
+})
+
+describe('the threshold still governs a reducer', () => {
+	it('does not run one below the trigger', async () => {
+		const reduce = vi.fn(() => undefined)
+		const h = harness({
+			contextReducer: reduce,
+			// A window far larger than the history.
+			compaction: { contextWindowTokens: 10_000_000 },
+		})
+
+		await runCompactionCheck(h.ctx)
+
+		expect(reduce).not.toHaveBeenCalled()
+	})
+
+	it('runs one below the trigger when the provider forced the issue', async () => {
+		const reduce = vi.fn(() => undefined)
+		const h = harness({
+			contextReducer: reduce,
+			compaction: { contextWindowTokens: 10_000_000 },
+		})
+
+		await runCompactionCheck(h.ctx, { force: true })
+
+		expect(reduce).toHaveBeenCalledOnce()
+	})
+})

package/src/runtime/query/iteration/phases/context.ts

@@ -1,6 +1,7 @@
 import type { AdvisoryContext } from '../../../../advisory/context.js'
 import type { AgentBus } from '../../../../bus/index.js'
 import type { WorkingStateManager } from '../../../../compaction/manager.js'
+import type { ContextReducer } from '../../../../compaction/reducer.js'
 import type { CompactionConfig } from '../../../../config/runtime.js'
 import type { PlanManager } from '../../../../manager/plan/lifecycle.js'
 import type { RunPersistence } from '../../../../manager/run/persistence.js'
@@ -14,6 +15,7 @@ import type {
 } from '../../../../types/hitl/index.js'
 import type { TaskId } from '../../../../types/ids/index.js'
 import type { LLMProvider } from '../../../../types/provider/index.js'
+import type { TaskRouterConfig } from '../../../../types/router/index.js'
 import type { ReviewAnswer } from '../../../../types/run/answer-review.js'
 import type {
 	AgentRunConfig,
@@ -104,10 +106,19 @@ export interface IterationContext {
 	 */
 	readonly toolGrants?: ToolGrantSet
 
+	/** Per-task model overrides. Consulted for the compaction summary call. */
+	readonly taskRouter?: TaskRouterConfig
+
 	readonly compactionConfig?: CompactionConfig
 
 	readonly workingStateManager?: WorkingStateManager
 
+	/**
+	 * Host-supplied context reduction. Outranks `compactionConfig.strategy`
+	 * and replaces the structured pass for this run.
+	 */
+	readonly contextReducer?: ContextReducer
+
 	readonly workingMemoryProvider?: WorkingMemoryProvider
 
 	readonly advisoryCtx?: AdvisoryContext

package/src/runtime/query/resume-run.ts

@@ -0,0 +1,93 @@
+import type { PendingDecision } from '../../types/hitl/index.js'
+import type { CheckpointStore } from '../../types/run/checkpoint-store.js'
+import type { Run } from '../../types/run/entity.js'
+import type { RunState } from '../../types/run/state.js'
+import { type QueryParams, drainQuery } from './index.js'
+import { type RunStateScope, loadRunState } from './run-state.js'
+
+/**
+ * What a resume attempt found.
+ *
+ * Three outcomes rather than a nullable `Run`, because the two failures
+ * mean opposite things to a caller. "No checkpoint" is a dead end — there
+ * is nothing to continue and starting fresh would be a different run
+ * wearing the same id. "Awaiting decision" is the run working as designed:
+ * it parked on a question, and continuing means answering it first.
+ */
+export type ResumeOutcome =
+	| { readonly resumed: false; readonly reason: 'no-checkpoint' }
+	| {
+			readonly resumed: false
+			readonly reason: 'awaiting-decision'
+			/** What to put in front of a human. */
+			readonly pending: PendingDecision
+			readonly state: RunState
+	  }
+	| { readonly resumed: true; readonly run: Run; readonly state: RunState }
+
+/**
+ * The half of a run that cannot be serialized, plus where to look.
+ *
+ * `messages` is deliberately absent. On resume the history comes from the
+ * checkpoint and any passed messages would be discarded, so accepting them
+ * would invite a caller to hand over a transcript that is silently ignored.
+ */
+export interface ResumeRunParams
+	extends Omit<QueryParams, 'messages' | 'runId' | 'resumeFromCheckpoint'> {
+	/** Identifies the run inside the checkpoint store. */
+	readonly scope: RunStateScope
+	/** Required to find the checkpoint; also threaded into the resumed run. */
+	readonly checkpointStore: CheckpointStore
+	/**
+	 * Resume a specific checkpoint instead of the one the store would pick.
+	 * Absent means the parked checkpoint if there is one, else the newest.
+	 */
+	readonly checkpointId?: RunState['checkpointId']
+}
+
+/**
+ * Continue a run that a different process started.
+ *
+ * Everything this needs already existed — `CheckpointManager` writes the
+ * history, budgets, working state, trace context and any park;
+ * `loadRunState` reads them back; `query` accepts `runId` +
+ * `resumeFromCheckpoint` and restores all of it. What was missing was the
+ * few lines that join them, so every host wrote their own — and in this
+ * repo nothing outside the SDK ever did, which means the whole path shipped
+ * untravelled.
+ *
+ * The division of labour is the one the mechanism already implies: the
+ * CALLER brings what cannot be serialized — the provider client, the tool
+ * registry, the sandbox, the working directory — and the STORE brings the
+ * state. A snapshot deliberately holds no socket, no client and no open
+ * file, so it could never have carried the first half.
+ *
+ * Refusing beats guessing at both failure points. A missing checkpoint does
+ * not silently become a fresh run under a recycled id, and a park is not
+ * resumed past without the answer it is waiting for.
+ */
+export async function resumeRun(params: ResumeRunParams): Promise<ResumeOutcome> {
+	const { scope, checkpointStore, checkpointId, pendingDecision, ...rest } = params
+
+	const state = await loadRunState(checkpointStore, scope, checkpointId)
+	if (!state?.checkpointId) return { resumed: false, reason: 'no-checkpoint' }
+
+	// A park is outstanding until it is answered. `resolvedAt` is what marks
+	// an answered one, so a checkpoint that carries a resolved decision is an
+	// ordinary resume, not a question waiting on anybody.
+	const outstanding = state.pending && !state.pending.resolvedAt ? state.pending : undefined
+	if (outstanding && !pendingDecision) {
+		return { resumed: false, reason: 'awaiting-decision', pending: outstanding, state }
+	}
+
+	const run = await drainQuery({
+		...rest,
+		messages: [],
+		runId: state.runId,
+		resumeFromCheckpoint: state.checkpointId,
+		checkpointStore,
+		...(pendingDecision ? { pendingDecision } : {}),
+	} as QueryParams)
+
+	return { resumed: true, run, state }
+}