mirror of
https://github.com/deepseek-ai/deepseek-harness
synced 2026-08-15 21:04:50 +00:00
b3f8b4c9c6
Behavioral gaps from the coverage audit (line coverage was already 100%; these
close BEHAVIOR gaps):
- fs-local: service-level writeText/editText pre-abort → FS_ABORTED (file
unchanged); concurrent guarded-write race and mixed write-vs-edit race (one
wins, one FS_STALE_VERSION, locks released); edit→edit version refresh at the
provider; the replaceIfVersion post-write version matches a fresh stat. fsio:
a mid-stream abort → FS_ABORTED (previously only pre-abort was covered).
- fs-policy: the agent-without-session owner rung ({agent:{}} → no owner →
createIfAbsent / FS_NOT_OBSERVED); fs/write-intent first-wins (symmetric to
the existing edit-intent test).
- tool-fs: abort-through-the-tool for read/write/edit (isError FS_ABORTED, file
unchanged); a deterministic tool-tier concurrent-edit race via a shared read;
the throwing-fs/observed contract (a throwing listener surfaces as isError but
the mutation already hit disk); the replace_all edit message; parseReadArgs
rejects fractional/NaN offset and zero/negative limit.
- dsh-fs: FsError chains a cause through ErrorOptions.
New with-key e2e (packages/fs/tool-fs/tests/fs-tools.e2e.ts, self-skips without
DEEPSEEK_API_KEY): a real model drives the real read/write/edit tools to create
→ read → edit a file, verified on disk; a second test proves a relative path
resolves against the per-session cwd (factory meta.cwd) not config.cwd. Booted
via a plain tests/harness.ts. Added dsh-agent-loop + dsh-llm-deepseek devDeps.
85 lines
3.8 KiB
TypeScript
85 lines
3.8 KiB
TypeScript
import { mkdtemp, readFile, rm } from 'node:fs/promises'
|
|
import { tmpdir } from 'node:os'
|
|
import { join } from 'node:path'
|
|
import { afterEach, describe, expect, it } from 'vitest'
|
|
import type { Context } from 'cordis'
|
|
import { AgentId } from '@deepseek-ai/dsh-agent'
|
|
import { SessionId } from '@deepseek-ai/dsh-session'
|
|
import { fsHarness, waitForIdle } from './harness.ts'
|
|
|
|
/**
|
|
* With-key smoke for the filesystem tools: a REAL model drives the REAL
|
|
* read/write/edit tools (over the real local backend + policy gate), and we
|
|
* verify the WORLD — the file on disk — not the agent's self-report. This is the
|
|
* "green units, broken product" guard: mocks prove the plumbing, only a real
|
|
* model proves the tools actually work end-to-end. Key-gated (self-skips without
|
|
* DEEPSEEK_API_KEY).
|
|
*/
|
|
|
|
let ctx: Context | undefined
|
|
let workdir: string | undefined
|
|
|
|
afterEach(async () => {
|
|
await ctx?.fiber.dispose()
|
|
ctx = undefined
|
|
if (workdir !== undefined) await rm(workdir, { recursive: true, force: true })
|
|
workdir = undefined
|
|
})
|
|
|
|
const SYSTEM = 'You are a coding assistant. Use the write tool to create files, the read tool to inspect '
|
|
+ 'them, and the edit tool for literal replacements. Read a file before editing it. Keep replies terse.'
|
|
|
|
describe.skipIf(!process.env.DEEPSEEK_API_KEY)('fs tools with-key smoke', () => {
|
|
it('creates, reads, then edits a file — verified on disk', async () => {
|
|
workdir = await mkdtemp(join(tmpdir(), 'dsh-fs-e2e-'))
|
|
ctx = await fsHarness(workdir)
|
|
// agentLoop.create prepares a session with no cwd, so the provider default
|
|
// (config.cwd = workdir) is the workspace.
|
|
const agent = ctx.agentLoop.create(AgentId('fs-e2e'), { model: 'deepseek-v4-flash', systemPrompt: SYSTEM })
|
|
|
|
agent.send([{ type: 'text', text:
|
|
'Create a file named note.txt containing exactly the line: status: draft. '
|
|
+ 'Then read it back, then edit it to replace the literal word draft with final. '
|
|
+ 'Tell me when done.' }])
|
|
await waitForIdle(ctx, agent)
|
|
|
|
// Verify the WORLD: the edit landed on disk.
|
|
const content = await readFile(join(workdir, 'note.txt'), 'utf8')
|
|
expect(content).toContain('status: final')
|
|
expect(content).not.toContain('draft')
|
|
|
|
// The log records real read/write/edit tool calls (not bash).
|
|
const calls = [...agent.session.events].filter(e => e.type === 'tool/call').map(e => e.data.name)
|
|
expect(calls).toContain('write')
|
|
expect(calls).toContain('read')
|
|
expect(calls).toContain('edit')
|
|
}, 180_000)
|
|
|
|
it('resolves a relative path against the per-session cwd (factory meta.cwd)', async () => {
|
|
// config.cwd is the harness workdir, but the agent's SESSION cwd is a
|
|
// different dir; the write must land in the SESSION dir, proving the tool
|
|
// passes the per-session cwd (not the backend default).
|
|
const configDir = await mkdtemp(join(tmpdir(), 'dsh-fs-e2e-cfg-'))
|
|
workdir = configDir
|
|
const sessionDir = await mkdtemp(join(tmpdir(), 'dsh-fs-e2e-session-'))
|
|
try {
|
|
ctx = await fsHarness(configDir)
|
|
const handle = ctx.agents.create({
|
|
agentId: AgentId('fs-e2e-cwd'),
|
|
sessionId: SessionId(`fs-e2e-cwd-${Date.now()}`),
|
|
meta: { cwd: sessionDir },
|
|
agentOptions: { model: 'deepseek-v4-flash', systemPrompt: SYSTEM },
|
|
})
|
|
handle.agent.send([{ type: 'text', text:
|
|
'Use the write tool to create a file named where.txt containing exactly the line: here. Tell me when done.' }])
|
|
await waitForIdle(ctx, handle.agent)
|
|
|
|
// The file is in the SESSION dir, not the config dir.
|
|
expect(await readFile(join(sessionDir, 'where.txt'), 'utf8')).toContain('here')
|
|
await expect(readFile(join(configDir, 'where.txt'), 'utf8')).rejects.toMatchObject({ code: 'ENOENT' })
|
|
} finally {
|
|
await rm(sessionDir, { recursive: true, force: true })
|
|
}
|
|
}, 180_000)
|
|
})
|