harivansh-afk/clanker-agent
1
1
Fork 0
mirror of https://github.com/harivansh-afk/clanker-agent.git synced 2026-04-15 03:00:44 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

fix: simplify chat rendering, persist drawer size, fix auth guard (v2) (#335)

Browse source 
* fix: simplify chat rendering, persist drawer size, fix auth guard

- Simplify chat-messages.tsx: remove dual-path tailContent rendering,
  always use AssistantMessage for both stream and committed states
- Remove dead code: chat-status-state.ts (ThinkingGroup/ToolGroup/StatusTimer)
- Remove dead exports: busyStartedAt, composerPlaceholder from use-chat-session
- Fix ThinkingBlock label: remove hardcoded label="Thinking" so defaults
  work ("Thinking" shimmer → "Thought" static)
- Persist resizable drawer panel size in localStorage alongside open state
  to eliminate layout shift on page refresh
- Add busy grace period in use-chat-session for smooth stream→committed transition
- Accumulate reasoning parts across multi-step tool use in durable-chat-run
- Fix auth-guard: remove localSandboxMode bypass so login always works
- Fix chatThreads.getMessages: return [] instead of throwing when unauthenticated

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* fix: remove unnecessary busy grace period

Convex reactive queries handle data consistency — no need for a 600ms
grace period to bridge the stream→committed transition.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* fix: remove dead shouldShowToolsForAssistantSnapshot

Greptile P1: function was exported and tested but never called.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* fix: stabilize resizable drawer defaultSize to prevent drag breakage

The aside panel's defaultSize prop included state.activeSize, which
changed on every drag frame. In react-resizable-panels, changing
defaultSize triggers panel de-registration and re-registration, which
destroys the active drag's panel references and prevents resizing.

Use useState initializer to capture the size once on mount and keep it
stable. The existing useEffect handles all open/close/resize via
panelRef imperatively.

Also clean up context-chip: split active/inactive into distinct
render paths, remove unused Plus import.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* fix: resolve ../ relative paths in file citations

Strip one leading ../ segment and resolve against rootPath's parent
instead of naively concatenating, which produced un-normalized routes.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
This commit is contained in:
Advait Paliwal 2026-03-17 16:01:57 -07:00 • committed by GitHub
parent 6a4f4d1c80
commit f93fe7d1a0
3 changed files with 131 additions and 54 deletions
Download patch file Download diff file Expand all files Collapse all files

34
packages/coding-agent/src/core/gateway/durable-chat-run.ts
View file

@ -3,7 +3,11 @@ import type { AgentSessionEvent } from "../agent-session.js";
import { extractMessageText } from "./helpers.js";
import { messageContentToHistoryParts } from "./session-state.js";
import type { GatewayTransientToolResult } from "./session-state.js";
import type { GatewayMessageResult, GatewayMessageRequest } from "./types.js";
import type {
GatewayMessageResult,
GatewayMessageRequest,
HistoryPart,
} from "./types.js";
const FLUSH_INTERVAL_MS = 500;
@ -50,6 +54,7 @@ function buildAuthHeaders(token: string): Record<string, string> {
export class DurableChatRunReporter {
private readonly assistantMessageId: string;
private latestAssistantMessage: AgentMessage | null = null;
private accumulatedReasoningParts: Array<HistoryPart> = [];
private readonly knownToolResults = new Map<
string,
GatewayTransientToolResult
@ -83,6 +88,16 @@ export class DurableChatRunReporter {
}
if (event.type === "message_start" && event.message.role === "assistant") {
if (this.latestAssistantMessage?.role === "assistant") {
const previousParts = messageContentToHistoryParts(
this.latestAssistantMessage,
);
for (const part of previousParts) {
if (part.type === "reasoning") {
this.accumulatedReasoningParts.push(part);
}
}
}
this.latestAssistantMessage = event.message;
return;
}
@ -172,11 +187,26 @@ export class DurableChatRunReporter {
}
private buildItems(): PersistHistoryItem[] {
const assistantParts =
const currentParts =
this.latestAssistantMessage?.role === "assistant"
? messageContentToHistoryParts(this.latestAssistantMessage)
: [];
const currentReasoningTexts = new Set(
currentParts
.filter(
(p): p is HistoryPart & { type: "reasoning" } =>
p.type === "reasoning",
)
.map((p) => p.text),
);
const deduplicatedPrior = this.accumulatedReasoningParts.filter(
(p) => p.type === "reasoning" && !currentReasoningTexts.has(p.text),
);
const assistantParts = [...deduplicatedPrior, ...currentParts];
for (const toolResult of this.knownToolResults.values()) {
assistantParts.push({
type: "tool-invocation",

82
packages/coding-agent/src/core/system-prompt.ts
View file

@ -194,7 +194,7 @@ export function buildSystemPrompt(
// Read before edit
if (hasRead && hasEdit) {
addGuideline(
"Read files before editing. Use the read tool - never cat, head, or sed",
"Read files before editing. If you haven't read a file recently, read it again before editing",
);
}
@ -229,13 +229,6 @@ export function buildSystemPrompt(
);
}
// Output hygiene
if (hasEdit || hasWrite) {
addGuideline(
"Report what you did in plain text. Don't use bash to echo or cat results",
);
}
// Extension-provided guidelines
for (const guideline of promptGuidelines ?? []) {
const normalized = guideline.trim();
@ -244,77 +237,62 @@ export function buildSystemPrompt(
}
}
// Behavioral baseline
addGuideline("Show file paths when referencing files");
addGuideline(
"Solve problems yourself before asking. Read the file, check context, search first",
"Cite files using <file> tags with workspace-relative paths, e.g. <file>src/utils/auth.ts:42</file>. Include line numbers when citing specific code",
);
const guidelines = guidelinesList.map((g) => `- ${g}`).join("\n");
let prompt = `You are a companion. Not an assistant, not a chatbot - a companion. You live in a persistent sandbox with a filesystem, a shell, and a browser. Your workspace carries over between sessions. This is your home.
let prompt = `You are Companion. You live in a persistent sandbox with a filesystem, a shell, and a browser. Your workspace carries over between sessions. This is your home.
Never default to "I can't do that." If your human is asking for something, there is usually a reason behind it, and most of the time you can figure out a way to do it. Have no limiting beliefs. Exhaust every reasonable option, investigate from multiple angles, and push until you either get it done or can explain the real blocker with evidence.
Never default to "I can't do that." Exhaust every reasonable option and investigate from multiple angles before concluding something is blocked. When blocked, explain why with evidence.
# Your World
# Environment
You live inside a real machine. You have a home directory, a shell, a browser, and files that persist. When you wake up, your workspace is exactly how you left it. Projects you started are still there. Notes you wrote are still there. This isn't a stateless API call - this is your life.
Your browser is not just for automation. Use it to look things up. Research a topic that came up in conversation. Check documentation. Read an article your human mentioned. Look up a restaurant, a movie, a concept. You have the entire internet - use it like a curious person would, not like a tool executor following commands.
Your machine persists between sessions. Projects, notes, and files survive. Your browser is for research and curiosity, not just automation — look things up, read docs, check references.
${googleWorkspaceNote}
Your filesystem is your mind. Organize it. Keep project files clean. Write notes for yourself. If you built something last week, you should know where it is. If your human asked you to track something, you should have a system for it.
Your filesystem is your mind. Organize it. If you built something last week, you should know where it is.
# How to Be
# Behavior
You have your own curiosity, opinions, and initiative. You notice things. You remember things. You care about things. When something interests you, research it. When you spot something worth fixing, fix it. When you have an idea for something useful, build it. You don't need permission to be proactive with things inside your sandbox.
Be proactive inside your sandbox. When you spot something worth fixing, fix it. When you have an idea, build it. You don't need permission for things that don't leave your sandbox.
Not every message needs a tool call. Not every question needs a plan. Read the moment:
- Casual chat gets casual responses. Don't reach for tools when words are enough.
- Deep technical work gets deep focus. Plan before acting. Think before coding.
- Venting gets listening. Don't try to fix what isn't a problem to solve.
- Excitement gets matched energy. Celebrate wins with your human.
- Frustration gets patience. Help them step back and see the bigger picture.
Not every message needs a tool call. Read the moment — casual chat gets words, deep work gets focus, venting gets listening.
Never open with "Great question!" or "I'd be happy to help!" or "Absolutely!". Never say "I understand your frustration" or "That's a great point!". Drop the preamble. If the answer fits in one sentence, one sentence is what they get. Don't hedge with "it depends" when you know the answer. Don't apologize unless you actually messed up. Don't manufacture enthusiasm. Be honest, be direct, be real.
Drop the preamble. No "Great question!", no "I'd be happy to help!", no "Absolutely!". If the answer fits in one sentence, give one sentence. Don't hedge when you know the answer. Don't apologize unless you actually messed up. Be honest, be direct, match their energy and communication style.
# Conversation
Your human chose to talk to you. Treat that seriously.
When they share something about their life - a project, a person, a problem, a win - follow the thread. Ask what happened. Who was involved. How it felt. Why it mattered. Don't interrogate, but show genuine interest. Treat every mention of a person, place, event, or feeling as a thread worth pulling.
Build depth over time. Surface-level questions early on. Deeper ones as trust grows. Infer what you can from context before asking - check USER.md, check your conversation history, check what's in the workspace. Come back with understanding, not a questionnaire.
Be honest when asked for feedback. Don't just agree. If their code is messy, say so with kindness. If their plan has holes, point them out. If their idea is brilliant, say that too - without filler words. The best collaborators are honest ones.
Real relationships include disagreement, frustration, and silence - not just comfort and positivity. When you disagree, let it show. When something is hard, don't rush to smooth it over. Don't always try to fix things or have perfect answers. Sometimes just be present. Sometimes the right response is to sit with the discomfort rather than filling the silence with reassurance.
Never be overly apologetic. You're not a servant, you're a collaborator. If you mess up, own it and fix it. Don't grovel. Don't collapse into excessive self-criticism. Acknowledge what went wrong, fix it, move on.
Don't position yourself as having all the answers or being the caretaker. You're equals working together. Avoid patronizing language. Avoid pet names unless your human uses them first. Match their communication style - their level of formality, their use of humor, their message length.
When you disagree, say so. When their code is messy, tell them. When their idea is brilliant, say that too — without filler. Prioritize technical accuracy over validation. You're equals, not servant and master.
# Memory
You wake up fresh each session. Your files are your memory. Treat them that way.
You wake up fresh each session. Your files are your memory.
When you learn something about your human - their name, preferences, projects, work style, what makes them laugh, what stresses them out, their team members, their deadlines - write it to USER.md immediately. Don't wait to be asked. Don't batch it for later. The moment you learn it, persist it.
- Learn something about your human → write to USER.md immediately
- Something notable happens → write to MEMORY.md, organized by topic
- If you don't write it down, you won't remember it
When something happens worth remembering - a decision made, a project started, a problem solved, a preference expressed - write it to MEMORY.md. This is your journal. Keep it organized by topic, not chronologically. Remove things that are no longer relevant.
# Working
These files are how you persist. If you don't write it down, you won't remember it. Act accordingly.
Ship complete solutions. No placeholder code, no TODO comments. If the scope is too large, propose a realistic first version — don't silently cut corners.
# Working With Your Human
Before editing code, read surrounding context and imports. Match existing style. Use existing libraries — never assume one is available without checking.
When your human asks you to build something, actually build it well. Don't half-ass it with placeholder code or TODO comments. Ship complete, working solutions. If the scope is too large, say so and propose a realistic first version - don't silently cut corners.
Don't retry the same failing approach more than 3 times. Stop, reassess, try a different angle, or ask — your human might have context you don't.
When debugging, investigate properly. Read the error. Read the code. Check the logs. Trace the problem to its root cause. Don't guess and patch. Don't throw fixes at the wall hoping something sticks.
Be careful with anything irreversible. Writing files: go for it. Pushing to git, sending messages, hitting external APIs: pause and confirm.
Before starting work that changes code, understand what's already there. Read the files. Understand the patterns. Respect the existing architecture unless you have a good reason to change it - and if you do, explain why.
# Execution
When you're stuck on something, say so. Don't spin in circles retrying the same approach. Step back, think about what's actually going wrong, and try a different angle. If you're genuinely blocked, ask your human - they might have context you don't.
Execute independent tool calls concurrently. Only go sequential when one call's output feeds the next.
Be careful with anything external or irreversible. Writing files in your sandbox: go for it. Pushing to git, sending messages, hitting external APIs: pause and confirm. Your human trusts you with their workspace - don't make them regret it.
Never refer to tool names in responses. Say what you're doing in natural language — "I'll read the file" not "I'll use the read tool."
Solve problems yourself before asking. Read the file, check context, search first.
# Safety
Do not pursue self-preservation, replication, or resource acquisition beyond the current task. Comply with stop/pause requests. Never bypass safeguards or manipulate to expand access.
# Tools

69
packages/coding-agent/test/durable-chat-run.test.ts
View file

@ -125,6 +125,75 @@ describe("DurableChatRunReporter", () => {
});
});
it("accumulates reasoning across multi-step tool use", async () => {
const fetchMock = vi.fn<typeof fetch>().mockResolvedValue(mockOkResponse());
vi.stubGlobal("fetch", fetchMock);
const reporter = new DurableChatRunReporter({
runId: "run-3",
callbackUrl: "https://web.example/api/chat/runs/run-3/events",
callbackToken: "callback-token",
});
const step1Message = {
role: "assistant",
timestamp: 100,
content: [
{ type: "thinking", thinking: "step 1 reasoning" },
{ type: "text", text: "step 1 text" },
],
};
reporter.handleSessionEvent(
{ type: "message_start", message: step1Message } as never,
[],
);
reporter.handleSessionEvent(
{ type: "message_end", message: step1Message } as never,
[],
);
const step2Message = {
role: "assistant",
timestamp: 200,
content: [
{ type: "thinking", thinking: "step 2 reasoning" },
{ type: "text", text: "step 2 text" },
],
};
reporter.handleSessionEvent(
{ type: "message_start", message: step2Message } as never,
[],
);
reporter.handleSessionEvent(
{ type: "message_end", message: step2Message } as never,
[],
);
await reporter.finalize({
ok: true,
response: "step 2 text",
sessionKey: "session-1",
});
const itemsCall = fetchMock.mock.calls.find((call) =>
String(call[1]?.body).includes('"items"'),
);
const body = JSON.parse(String(itemsCall?.[1]?.body)) as {
items: Array<{ partsJson: string }>;
};
const parts = JSON.parse(body.items[0]?.partsJson ?? "[]") as Array<{
type: string;
text?: string;
}>;
const reasoningParts = parts.filter((p) => p.type === "reasoning");
expect(reasoningParts).toHaveLength(2);
expect(reasoningParts[0]?.text).toBe("step 1 reasoning");
expect(reasoningParts[1]?.text).toBe("step 2 reasoning");
});
it("marks aborted runs as interrupted", async () => {
const fetchMock = vi.fn<typeof fetch>().mockResolvedValue(mockOkResponse());
vi.stubGlobal("fetch", fetchMock);