Skip to content

Commit dd883e8

Browse files
lidge-junwtfsayoclaude
authored
fix(devin): carry reasoning signatures across turns (carry #6116) (#6184)
* fix(devin): carry reasoning signatures across turns SWE-2 streams its #10 delta_signature and #21 delta_signature_type after the visible answer, so the Responses layer stores them as a signature-only reasoning item behind the thinking item. The replay mapping kept only thinking blocks with text, so the signature never went back, and GPT and Gemini rows, whose reasoning is signature-only, replayed nothing at all. - Decode #21 with #10 and carry the type inside the stored signature. - Replay one unsigned thinking block plus exactly one signature-only block as a single signed prompt (#11, #12, #18), and replay signature-only turns instead of dropping them. Existing rules stay: a signed block wins over a stray signature-only block, and ambiguous mixes go unsigned. Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]> (cherry picked from commit c483502) * fix(devin): never replay a Claude signature, and pin the signature-only wire Cognition streams Claude's thinking as a summary while the signature covers the original, so replaying the pair fails validation. Live on claude-opus-5-5 the next turn of a tool loop was refused with invalid_argument in 5 of 6 signed replays and 0 of 3 text-only ones, and dev already failed the same way intermittently (3 of 6) because it paired a single signed block. An Anthropic signature is now dropped and the thinking text replayed alone; a signature stored before its type was recorded falls back to the model being called. Through the proxy the failing tool loop then completed 6 of 6. Tests now check the signature-only turn's wire (#12 and #18, no #11) and that a signature-only turn with no text and no tool call is kept. Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]> (cherry picked from commit e61c7c3) * docs(structure): note the withheld Anthropic signature in Devin replay Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]> (cherry picked from commit e0b81e5) * fix(devin): replay Claude signatures and retry a refused turn without them Withholding every Anthropic signature stopped the invalid_argument refusals but also stopped Claude recalling its earlier reasoning: in the live benchmark claude-opus-5-5 matched 2 of 6 on dev and 0 of 6 with the signature withheld. The signature is sent again, and a turn Cognition refuses with invalid_argument before any output is retried once with the Anthropic signatures withheld and the thinking text kept. Other signature types and refusals after output are not retried. Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]> (cherry picked from commit ecd9eaa) * fix(devin): retry a refused Claude turn even after it streamed reasoning Live, Cognition's refusal of a signed Claude replay usually arrives after the model has streamed its reasoning, its signature and a finish frame, and nothing visible. Only visible output (text or tool calls) now blocks the retry, so those turns are retried without the signature instead of failing. Through the proxy the stress case completed 10 of 10 (dev failed 3 of 6) and recalled the hidden number 7 of 10. Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]> (cherry picked from commit bfc56f5) * docs(structure): the Claude signature retry ignores reasoning-only output Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]> (cherry picked from commit 073ef93) * fix(devin): hold the signed attempt's reasoning until its outcome is known The fallback yielded the signed attempt's reasoning and signature before it knew whether Cognition would refuse the turn, so a successful unsigned retry left the client holding the refused attempt's signature, which the next turn would replay against the retry's thinking. When a fallback is possible, the signed attempt's events are now held until its first visible output or a clean finish, and discarded when the retry starts. Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]> (cherry picked from commit 796b07f) * fix(devin): heartbeat while signed reasoning is held, and keep the refused attempt's usage - While the signed attempt's events are held, a plain heartbeat goes out at most every 15 seconds, so a long reasoning phase does not trip the bridge's upstream stall deadline. The held reasoning and signature stay held until the retry decision. - The refused attempt was processed, so its final usage is added to every usage frame of the unsigned retry (frames are cumulative per request) instead of being dropped with its reasoning. Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]> (cherry picked from commit 37848f4) * fix(devin): report the refused attempt's usage before the retry starts The refused attempt's usage reached the turn only through the retry's usage frames, so a retry that reported no usage, or failed before its first frame, dropped those tokens again. It is now emitted before the retry and still added to every later retry frame. Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]> (cherry picked from commit 78d62ed) * fix(devin): pair late signatures only with adjacent reasoning Co-authored-by: Sayo <[email protected]> * fix(devin): heartbeat while signed reasoning waits for trailer Co-authored-by: Sayo <[email protected]> * fix(devin): bound held signed reasoning before streaming Co-authored-by: Sayo <[email protected]> * test(devin): retry signed refusal before history overflow classification Co-authored-by: Sayo <[email protected]> * docs(devin): explain reasoning continuity and fallback bounds Co-authored-by: Sayo <[email protected]> * fix(devin): include held signatures in payload bound Co-authored-by: Sayo <[email protected]> * docs(devin): keep adapter inventory table intact Co-authored-by: Sayo <[email protected]> * fix(devin): stop held heartbeat before release on error Co-authored-by: Sayo <[email protected]> * docs(structure): carry the model and wire rules into the restacked Devin row Co-authored-by: Sayo <[email protected]> * fix(devin): preserve signed refusal when retry budget is exhausted Co-authored-by: Sayo <[email protected]> * fix(devin): merge all held signature-attempt usage frames Co-authored-by: Sayo <[email protected]> --------- Co-authored-by: Sayo <[email protected]> Co-authored-by: Claude Opus 5.5 (1M context) <[email protected]>
1 parent da874dd commit dd883e8

9 files changed

Lines changed: 704 additions & 55 deletions

File tree

‎docs-site/src/content/docs/reference/adapters.md‎

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -560,6 +560,9 @@ configuration that names the old id is rewritten at startup.
560560
- Uses `runTurn` rather than the ordinary fetch/parse path. Requests and server events are encoded
561561
with manual protobuf framing in `devin/cloud-direct/wire.ts`; the ordinary `buildRequest` /
562562
`parseStream` path is disabled.
563+
- Reasoning continuity carries provider signatures across turns. If Cognition refuses a signed
564+
Anthropic replay before visible output, Devin retries once with the signature withheld and the
565+
thinking text preserved.
563566
- Live model discovery via `GetCascadeModelConfigs`; the static seed is filtered against the
564567
account's live roster so models not on the plan drop out instead of failing at request time.
565568
- Tool definitions are encoded in the request and tool-call events are decoded from the response

‎scripts/test-layout/layout.json‎

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -759,6 +759,8 @@
759759
"devin-provider-merge-migration.test.ts": "providers",
760760
"devin-stated-reset-hardening.test.ts": "providers",
761761
"devin-stated-reset-retry.test.ts": "providers",
762+
"devin-anthropic-signature-fallback.test.ts": "providers",
763+
"devin-reasoning-continuation.test.ts": "providers",
762764
"devin-stream-deadline.test.ts": "providers",
763765
"digitalocean-scaleway-provider.test.ts": "providers",
764766
"docs-429-failover-claims.test.ts": "ci-workflows",

‎src/adapters/devin.ts‎

Lines changed: 143 additions & 52 deletions
Original file line numberDiff line numberDiff line change
@@ -10,12 +10,12 @@ import type { AdapterEvent, OcxAssistantMessage, OcxContentPart, OcxMessage, Ocx
1010
import { namespacedToolName } from "../types";
1111
import type { IncomingMeta, ProviderAdapter } from "./base";
1212
import { streamChatEventsWithResetRetry, devinStatedResetWaitMs, allocateCascadeId, CloudChatError, type ChatHistoryItem, type ToolDef } from "./devin/cloud-direct";
13-
import type { ContentPart } from "./devin/cloud-direct/chat";
13+
import type { CloudChatEvent, ContentPart } from "./devin/cloud-direct/chat";
1414
import { getCachedCatalog, type CacheEntry, type ModelCatalogEntry } from "./devin/cloud-direct/catalog";
1515
import { collapseDevinModelUid, devinFamiliesOf, devinFamilyBaseId, selectDevinFamilyMember, type DevinVariantRequest } from "./devin/live-models";
1616
import { buildNonOpenAIToolCatalogNudgeForTools } from "./tool-catalog-nudge";
1717
import { DEVIN_DEFAULT_API_SERVER, resolveDevinApiServer } from "../oauth/devin";
18-
import { isProviderIssuedThinkingSignature } from "../responses/reasoning-envelope";
18+
import { devinAssistantReasoning, encodeDevinSignature, hasAnthropicSignature } from "./devin/reasoning-signature";
1919
import { SendBudgetExhaustedError } from "../lib/upstream-retry";
2020
import { devinContextOverflowEvent, isDevinHistoryOverflow } from "./devin/context-overflow";
2121

@@ -55,6 +55,49 @@ export function mergeDevinUsage(previous: OcxUsage, next: OcxUsage): OcxUsage {
5555
*/
5656
const DEVIN_CLIENT_CLOSED_MESSAGE = "client closed request";
5757

58+
/** Below the bridge's upstream stall deadline, so held reasoning never reads as a stall. */
59+
const HELD_REASONING_HEARTBEAT_MS = 15_000;
60+
/** Once either limit is crossed, forward the signed attempt and disable fallback. */
61+
const HELD_REASONING_MAX_EVENTS = 1_024;
62+
const HELD_REASONING_MAX_PAYLOAD_BYTES = 1024 * 1024;
63+
64+
type DevinUsageEvent = Extract<CloudChatEvent, { kind: "usage" }>;
65+
66+
function toOcxDevinUsage(event: DevinUsageEvent): OcxUsage {
67+
const total = event.totalTokens ?? ((event.promptTokens ?? 0) + (event.completionTokens ?? 0));
68+
return {
69+
inputTokens: event.promptTokens ?? 0,
70+
outputTokens: event.completionTokens ?? 0,
71+
...(total > 0 ? { totalTokens: total } : {}),
72+
...(event.cachedInputTokens !== undefined ? { cachedInputTokens: event.cachedInputTokens } : {}),
73+
...(event.cacheCreationInputTokens !== undefined ? { cacheCreationInputTokens: event.cacheCreationInputTokens } : {}),
74+
...(event.reasoningTokens !== undefined ? { reasoningOutputTokens: event.reasoningTokens } : {}),
75+
};
76+
}
77+
78+
function toCloudDevinUsage(usage: OcxUsage): DevinUsageEvent {
79+
return {
80+
kind: "usage",
81+
promptTokens: usage.inputTokens,
82+
completionTokens: usage.outputTokens,
83+
totalTokens: usage.totalTokens,
84+
cachedInputTokens: usage.cachedInputTokens,
85+
cacheCreationInputTokens: usage.cacheCreationInputTokens,
86+
reasoningTokens: usage.reasoningOutputTokens,
87+
};
88+
}
89+
90+
/** The retry's cumulative usage plus the refused attempt's final counts. */
91+
function addDevinUsage(event: DevinUsageEvent, prior: DevinUsageEvent): DevinUsageEvent {
92+
const sum = (a?: number, b?: number) => (a === undefined && b === undefined ? undefined : (a ?? 0) + (b ?? 0));
93+
const out: DevinUsageEvent = { ...event };
94+
for (const key of ["promptTokens", "completionTokens", "totalTokens", "cachedInputTokens", "cacheCreationInputTokens", "reasoningTokens"] as const) {
95+
const value = sum(event[key], prior[key]);
96+
if (value !== undefined) out[key] = value;
97+
}
98+
return out;
99+
}
100+
58101
/** Map a cloud-direct failure onto the structured fields the error event carries. */
59102
export function devinErrorClassification(error: unknown): { status?: number; errorType?: string; retryable?: boolean } {
60103
const status = error instanceof CloudChatError ? error.status : undefined;
@@ -452,45 +495,16 @@ function assistantText(message: OcxAssistantMessage): string {
452495
// Thinking stays out of the replayed TEXT: folding chain-of-thought into
453496
// assistant text sends it back as visible prior output, which the model
454497
// then treats as something it said to the user. It is replayed in its own
455-
// field instead — see assistantThinking below.
498+
// field instead — see devinAssistantReasoning.
456499
.map((part) => (part.type === "text" ? part.text : ""))
457500
.filter(Boolean)
458501
.join("\n");
459502
}
460503

461-
/**
462-
* The assistant turn's own reasoning, for replay in ChatMessagePrompt #11.
463-
*
464-
* This adapter previously asserted that Cognition has no reasoning-replay
465-
* field and dropped the thinking outright, so a reasoning model restarted its
466-
* chain on every turn of a tool loop. The field exists: two independent
467-
* clients of the same service write #11 thinking with #12 signature and #18
468-
* signature_type on the assistant prompt.
469-
*
470-
* Field #12 attests the exact text at #11, and the wire has room for one pair.
471-
* Every block that carries text is replayed, so the chain stays intact; the
472-
* signature rides along only when the text being replayed IS the text it
473-
* attests, which is exactly the single-block case. Several independently signed
474-
* blocks send an unsigned prompt rather than pairing one block's attestation
475-
* with another block's words. A signature-only block attests encrypted thinking
476-
* that is not being replayed at all, so it is not one of these blocks and
477-
* cannot contribute the pair.
478-
*/
479-
function assistantThinking(
480-
message: OcxAssistantMessage,
481-
): { thinking?: string; signature?: string } {
482-
const blocks = message.content.filter(
483-
(part): part is Extract<typeof part, { type: "thinking" }> => part.type === "thinking",
484-
).filter(part => Boolean(part.thinking));
485-
if (blocks.length === 0) return {};
486-
const signature = blocks.length === 1 ? blocks[0]!.signature : undefined;
487-
return {
488-
thinking: blocks.map(part => part.thinking).join("\n"),
489-
...(isProviderIssuedThinkingSignature(signature) ? { signature } : {}),
490-
};
491-
}
492-
493-
export function mapOcxMessagesToDevin(parsed: OcxParsedRequest): ChatHistoryItem[] {
504+
export function mapOcxMessagesToDevin(
505+
parsed: OcxParsedRequest,
506+
options: { withholdAnthropicSignatures?: boolean } = {},
507+
): ChatHistoryItem[] {
494508
const items: ChatHistoryItem[] = [];
495509
// Cognition is not an OpenAI host, and this adapter does advertise a real
496510
// client tool catalog (proto #10 via `mapOcxToolsToDevin`), so the same
@@ -509,13 +523,17 @@ export function mapOcxMessagesToDevin(parsed: OcxParsedRequest): ChatHistoryItem
509523
if (system) items.push({ role: "system", content: system });
510524

511525
for (const message of parsed.context.messages) {
512-
const mapped = mapOneMessage(message);
526+
const mapped = mapOneMessage(message, parsed.modelId, options);
513527
if (mapped) items.push(mapped);
514528
}
515529
return items;
516530
}
517531

518-
function mapOneMessage(message: OcxMessage): ChatHistoryItem | undefined {
532+
function mapOneMessage(
533+
message: OcxMessage,
534+
modelId: string,
535+
options: { withholdAnthropicSignatures?: boolean },
536+
): ChatHistoryItem | undefined {
519537
if (message.role === "user" || message.role === "developer") {
520538
const content = mapOcxContentToWire(message.content);
521539
// An image with no caption text is a complete user message on its own.
@@ -527,10 +545,10 @@ function mapOneMessage(message: OcxMessage): ChatHistoryItem | undefined {
527545
if (message.role === "assistant") {
528546
const toolCalls = assistantToolCalls(message);
529547
const text = assistantText(message);
530-
const reasoning = assistantThinking(message);
548+
const reasoning = devinAssistantReasoning(message, modelId, options.withholdAnthropicSignatures === true);
531549
// A turn that produced only reasoning is still worth replaying: dropping it
532550
// is what makes the next turn re-derive the same chain.
533-
if (!text && toolCalls.length === 0 && !reasoning.thinking) return undefined;
551+
if (!text && toolCalls.length === 0 && !reasoning.thinking && !reasoning.signature) return undefined;
534552
return {
535553
role: "assistant",
536554
content: text || "",
@@ -746,7 +764,15 @@ export function createDevinAdapter(
746764
// An admitted HTTP turn owns globally shared capacity until this call
747765
// emits. Without an explicit wait allowance, preserve the typed reset
748766
// delay in generated diagnostic wording and return immediately.
749-
for await (const event of streamChatEventsWithResetRetry({
767+
const signedMessages = mapOcxMessagesToDevin(parsed);
768+
// A Claude signature is replayed because it is what carries the reasoning into this
769+
// turn, but Cognition streams Claude's thinking as a summary the signature does not
770+
// cover, and some replays are refused with invalid_argument before any output. That
771+
// refusal is retried once with the Anthropic signatures withheld and the text kept.
772+
const unsignedMessages = hasAnthropicSignature(signedMessages, parsed.modelId)
773+
? mapOcxMessagesToDevin(parsed, { withholdAnthropicSignatures: true })
774+
: undefined;
775+
const request = (messages: ChatHistoryItem[]) => streamChatEventsWithResetRetry({
750776
apiKey,
751777
apiServerUrl: host,
752778
modelUid,
@@ -770,7 +796,80 @@ export function createDevinAdapter(
770796
onPhysicalSend: incoming.onPhysicalSend,
771797
onRecoveryWithheld: incoming.onRecoveryWithheld,
772798
},
773-
})) {
799+
});
800+
async function* withSignatureFallback() {
801+
if (!unsignedMessages) {
802+
yield* request(signedMessages);
803+
return;
804+
}
805+
// Events from the signed attempt are held until its outcome is known: a refusal
806+
// after reasoning would otherwise leave the client with the refused attempt's
807+
// reasoning and signature, and the next turn would replay that signature against
808+
// the retry's thinking.
809+
const held: CloudChatEvent[] = [];
810+
// Usage is still real: the refused attempt was processed, so its final counts are
811+
// added to every usage frame of the retry (frames are cumulative per request).
812+
let refusedUsage: OcxUsage | undefined;
813+
let visible = false;
814+
let heldPayloadBytes = 0;
815+
// The iterator may pause before a trailer. A timer feeds the bridge during that
816+
// pause without starting another upstream read or marking replay unsafe.
817+
const heartbeatTimer = setInterval(() => {
818+
if (!visible) emit({ type: "heartbeat" });
819+
}, HELD_REASONING_HEARTBEAT_MS);
820+
try {
821+
for await (const event of request(signedMessages)) {
822+
// Only visible output makes a retry unsafe. Live, the refusal often lands after the
823+
// model has streamed its reasoning, its signature and a finish frame, and nothing else.
824+
if (!visible && (event.kind === "text" || event.kind === "tool_call_start" || event.kind === "tool_call_args")) {
825+
visible = true;
826+
clearInterval(heartbeatTimer);
827+
yield* held.splice(0);
828+
}
829+
if (visible) {
830+
yield event;
831+
continue;
832+
}
833+
held.push(event);
834+
if (event.kind === "usage") {
835+
const next = toOcxDevinUsage(event);
836+
refusedUsage = refusedUsage ? mergeDevinUsage(refusedUsage, next) : next;
837+
}
838+
if (event.kind === "reasoning") heldPayloadBytes += event.text.length * 2;
839+
if (event.kind === "reasoning_signature") heldPayloadBytes += event.signature.length * 2;
840+
if (held.length > HELD_REASONING_MAX_EVENTS || heldPayloadBytes > HELD_REASONING_MAX_PAYLOAD_BYTES) {
841+
visible = true;
842+
clearInterval(heartbeatTimer);
843+
yield* held.splice(0);
844+
}
845+
}
846+
} catch (error) {
847+
clearInterval(heartbeatTimer);
848+
if (visible || !(error instanceof CloudChatError && error.code === "invalid_argument")) {
849+
yield* held.splice(0);
850+
throw error;
851+
}
852+
// Emitted first so the counts survive a retry that reports no usage or fails early.
853+
const cumulativeRefusedUsage = refusedUsage ? toCloudDevinUsage(refusedUsage) : undefined;
854+
if (cumulativeRefusedUsage) yield cumulativeRefusedUsage;
855+
try {
856+
for await (const event of request(unsignedMessages)) {
857+
yield event.kind === "usage" && cumulativeRefusedUsage ? addDevinUsage(event, cumulativeRefusedUsage) : event;
858+
}
859+
} catch (retryError) {
860+
if (retryError instanceof SendBudgetExhaustedError) {
861+
incoming.onRecoveryWithheld?.({ reason: "retry-send-budget" });
862+
throw error;
863+
}
864+
throw retryError;
865+
}
866+
return;
867+
} finally {
868+
clearInterval(heartbeatTimer);
869+
}
870+
yield* held.splice(0);
871+
}
872+
for await (const event of withSignatureFallback()) {
774873
if (incoming.abortSignal?.aborted) {
775874
// Emitting nothing here left the bridge to synthesize adapter_eof.
776875
// Say what happened instead, the way the other runTurn-only adapter
@@ -792,7 +891,7 @@ export function createDevinAdapter(
792891
if (event.kind === "reasoning_signature") {
793892
// Carried back out so the next turn can replay it in the prompt's
794893
// signature field; an unsigned replay is what the service ignores.
795-
emit({ type: "thinking_signature", signature: event.signature });
894+
emit({ type: "thinking_signature", signature: encodeDevinSignature(event.signature, event.signatureType) });
796895
continue;
797896
}
798897
if (event.kind === "tool_call_start") {
@@ -820,15 +919,7 @@ export function createDevinAdapter(
820919
continue;
821920
}
822921
if (event.kind === "usage") {
823-
const total = event.totalTokens ?? ((event.promptTokens ?? 0) + (event.completionTokens ?? 0));
824-
const next: OcxUsage = {
825-
inputTokens: event.promptTokens ?? 0,
826-
outputTokens: event.completionTokens ?? 0,
827-
...(total > 0 ? { totalTokens: total } : {}),
828-
...(event.cachedInputTokens !== undefined ? { cachedInputTokens: event.cachedInputTokens } : {}),
829-
...(event.cacheCreationInputTokens !== undefined ? { cacheCreationInputTokens: event.cacheCreationInputTokens } : {}),
830-
...(event.reasoningTokens !== undefined ? { reasoningOutputTokens: event.reasoningTokens } : {}),
831-
};
922+
const next = toOcxDevinUsage(event);
832923
// Merge rather than replace. A turn can carry more than one usage
833924
// frame, and the counters are cumulative, so a later partial frame
834925
// that omits a field used to zero a count the earlier frame had

‎src/adapters/devin/cloud-direct/chat.ts‎

Lines changed: 7 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -494,7 +494,7 @@ export type CloudChatEvent =
494494
* turn produced. Without decoding it there is nothing to put in the prompt's
495495
* #12 on the next turn, so the replay would always be unsigned.
496496
*/
497-
| { kind: 'reasoning_signature'; signature: string }
497+
| { kind: 'reasoning_signature'; signature: string; signatureType?: string }
498498
| { kind: 'tool_call_start'; id: string; name: string }
499499
| {
500500
kind: 'tool_call_args';
@@ -817,6 +817,10 @@ export function* decodeChatFrame(proto: Buffer): Generator<CloudChatEvent> {
817817
}
818818
}
819819
if (authoritativeUsage) yield authoritativeUsage;
820+
let signatureType: string | undefined;
821+
for (const f of iterFields(proto)) {
822+
if (f.num === 21 && f.wire === 2 && Buffer.isBuffer(f.value)) signatureType = (f.value as Buffer).toString('utf8') || undefined;
823+
}
820824
for (const f of iterFields(proto)) {
821825
if (f.num === 3 && f.wire === 2 && Buffer.isBuffer(f.value)) {
822826
// Visible delta_text — what the user should SEE in the chat.
@@ -842,7 +846,8 @@ export function* decodeChatFrame(proto: Buffer): Generator<CloudChatEvent> {
842846
if (s) yield { kind: 'reasoning', text: s };
843847
} else if (f.num === 10 && f.wire === 2 && Buffer.isBuffer(f.value)) {
844848
const s = (f.value as Buffer).toString('utf8');
845-
if (s) yield { kind: 'reasoning_signature', signature: s };
849+
// #21 delta_signature_type arrives in the same frame; the prompt replays it as #18.
850+
if (s) yield { kind: 'reasoning_signature', signature: s, ...(signatureType ? { signatureType } : {}) };
846851
} else if (f.num === 6 && f.wire === 2 && Buffer.isBuffer(f.value)) {
847852
let id: string | undefined;
848853
let name: string | undefined;

0 commit comments

Comments
 (0)