vi.mock("./models-config.providers.js", () => ({

applyNativeStreamingUsageCompat: (providers: unknown) => providers,

enforceSourceManagedProviderSecrets: ({ providers }: { providers: unknown }) => providers,

normalizeProviderCatalogModelsForConfig: (providers: unknown) => providers,

normalizeProviders: ({ providers }: { providers: unknown }) => providers,

resolveImplicitProviders: async ({

explicitProviders,

? (JSON.parse(plan.contents) as { providers?: Record<string, unknown> })

: {};

const provider = parsed.providers?.["github-copilot"];

expect(provider).not.toBeNull();

expect(typeof provider).toBe("object");

if (provider === null || typeof provider !== "object") {

throw new Error("Expected GitHub Copilot provider config");

}

function fetchInit(fetchMock: { mock: { calls: unknown[][] } }, callIndex = 0): RequestInit {

const init = callArg(fetchMock, callIndex, 1);

expect(typeof init).toBe("object");

expect(init).not.toBeNull();

if (!init || typeof init !== "object") {

throw new Error(`expected fetch init for call ${callIndex}`);

}

return init as RequestInit;

}

};

function requireRecord(value: unknown, label: string): Record<string, unknown> {

expect(value, label).toBeTypeOf("object");

expect(value, label).not.toBeNull();

if (!value || typeof value !== "object") {

throw new Error(`expected ${label}`);

}

return value as Record<string, unknown>;

}

}

function requireRecord(value: unknown, label: string): Record<string, unknown> {

expect(value, label).toBeTypeOf("object");

expect(value, label).not.toBeNull();

if (!value || typeof value !== "object") {

throw new Error(`expected ${label}`);

}

return value as Record<string, unknown>;

}

}

function requireRecord(value: unknown, label: string): Record<string, unknown> {

expect(typeof value).toBe("object");

expect(value).not.toBeNull();

if (typeof value !== "object" || value === null) {

throw new Error(`${label} was not an object`);

}

const mockCallGateway = vi.mocked(callGatewayTool);

function requireRecord(value: unknown, label: string): Record<string, unknown> {

expect(typeof value).toBe("object");

expect(value).not.toBeNull();

if (typeof value !== "object" || value === null) {

throw new Error(`${label} was not an object`);

}

});

const locationMatch = prompt.match(/<location>([^<]+)<\/location>/);

expect(locationMatch).not.toBeNull();

expect(locationMatch![1]).toContain("~/");

expect(locationMatch![1]).toContain("\\literal-skill");

if (!locationMatch) {

throw new Error("expected prompt location tag");

}

expect(locationMatch[1]).toContain("~/");

expect(locationMatch[1]).toContain("\\literal-skill");

});

it("preserves paths outside home directory", () => {