infinitecampus-mcp 2.3.4 → 2.3.6

package/dist/client.js

@@ -1,10 +1,19 @@
 import { writeFile, stat } from 'fs/promises';
 import { dirname } from 'path';
 import { parseCookieJar } from '@chrischall/mcp-utils';
+import { createCookieSessionManager } from '@chrischall/mcp-utils/session';
 const SESSION_TTL_MS = 5 * 60 * 60 * 1000; // 5h, slightly under IC's typical 6h
 export class ICClient {
     accounts = new Map();
-    sessions = new Map();
+    /**
+     * One CookieSessionManager per district (primary + each discovered linked
+     * district). The manager owns the session lifecycle: single-flight login,
+     * `withSession` exactly-one 401 replay, `invalidate()`, permanent-error
+     * caching, proactive `maxAgeMs` (SESSION_TTL_MS) expiry, and — for linked
+     * districts — the CUPS-minted session installed via `seed()` during
+     * discovery.
+     */
+    managers = new Map();
     linkedTo = new Map(); // linkedDistrictName → primaryDistrictName
     primaryName;
     featuresCache = new Map();
@@ -17,6 +26,8 @@ export class ICClient {
      */
     fetchproxyMode = false;
     fetchproxyDiscoveryRan = false;
+    /** fetchproxy cookies, consumed by the primary manager's first login. */
+    preloaded = null;
     /**
      * `preloaded` is the fetchproxy escape hatch: when set, the client treats
      * the supplied cookies as a freshly-completed login on the primary account.
@@ -29,27 +40,73 @@ export class ICClient {
     constructor(account, opts = {}) {
         this.accounts.set(account.name, account);
         this.primaryName = account.name;
+        this.managers.set(account.name, this.makeManager(account));
         if (opts.preloaded) {
-            this.sessions.set(account.name, {
-                cookie: opts.preloaded.cookieHeader,
-                xsrfToken: opts.preloaded.xsrfToken,
-                loggedInAt: Date.now(),
-                loginInFlight: null,
-            });
+            this.preloaded = opts.preloaded;
             this.fetchproxyMode = true;
         }
     }
+    /**
+     * Build the per-district CookieSessionManager.
+     *
+     * - `maxAgeMs: SESSION_TTL_MS` makes `ensure()` proactively invalidate and
+     *   re-login a session older than 5h (single-flight), replacing IC's old
+     *   hand-rolled `ensureFresh` wrapper. `now` reads `Date.now` at call time so
+     *   the clock stays mockable in tests.
+     * - `isPermanentError` caches the one config error the process can never
+     *   recover from (fetchproxy no-creds) so `ensure()` fails fast instead of
+     *   pointlessly retrying a login that can never succeed.
+     * - `onReplayLoginError` rethrows the re-login failure from `withSession`'s
+     *   expiry-replay path. By default that failure is swallowed and the stale
+     *   401 returned; rethrowing surfaces the actionable error (e.g. fetchproxy's
+     *   "sign back into your IC portal in the browser") to the caller instead of
+     *   a generic SessionExpiredError — the behavior IC's `lastLoginError`
+     *   bookkeeping used to provide.
+     */
+    makeManager(account) {
+        return createCookieSessionManager({
+            login: () => this.login(account),
+            isExpired: (res) => this.detectExpiredSession(account.name, res),
+            isPermanentError: (e) => e instanceof AuthFailedError && e.permanent,
+            maxAgeMs: SESSION_TTL_MS,
+            now: () => Date.now(),
+            onReplayLoginError: (err) => { throw err; },
+        });
+    }
+    /**
+     * `isExpired` predicate for `withSession`: a 401 means the session died.
+     * Side effect for linked districts: the shared CUPS SSO umbrella died with
+     * it, so drop the primary and every *sibling* linked session too — the
+     * linked district's re-login (via `login()`'s linked branch) then re-logs
+     * the primary in, whose discovery re-establishes all of them. `withSession`
+     * invalidates the requesting district itself. Mirrors the old hand-rolled
+     * doRequest 401 handling.
+     */
+    detectExpiredSession(district, res) {
+        if (res.status !== 401)
+            return false;
+        const primaryName = this.linkedTo.get(district);
+        if (primaryName) {
+            this.managers.get(primaryName).invalidate();
+            for (const linked of this.linkedTo.keys()) {
+                if (linked !== district)
+                    this.managers.get(linked).invalidate();
+            }
+        }
+        return true;
+    }
     async ensureDiscovery() {
         // Ensure primary account is logged in, which triggers CUPS linked-district discovery
-        await this.ensureSession(this.accounts.get(this.primaryName));
-        // fetchproxy mode skips login() and therefore the discovery call inside
-        // it. Run discovery directly the first time someone asks for it. The
-        // primary is never in linkedTo (it's the root of the linkedTo map). When
-        // login() is called for an already-linked district during a TTL refresh,
-        // it re-auths through the primary instead of running discovery itself.
+        const session = await this.managers.get(this.primaryName).ensure();
+        // fetchproxy mode skips the verify.jsp login and therefore the discovery
+        // call inside it. Run discovery directly the first time someone asks for
+        // it. The primary is never in linkedTo (it's the root of the linkedTo
+        // map). When login() runs for an already-linked district during a TTL
+        // refresh, it re-auths through the primary instead of running discovery
+        // itself.
         if (this.fetchproxyMode && !this.fetchproxyDiscoveryRan) {
             this.fetchproxyDiscoveryRan = true;
-            await this.discoverLinkedDistricts(this.accounts.get(this.primaryName));
+            await this.discoverLinkedDistricts(this.accounts.get(this.primaryName), session);
         }
     }
     listDistricts() {
@@ -86,66 +143,57 @@ export class ICClient {
             if (!account)
                 throw new UnknownDistrictError(district, [...this.accounts.keys()]);
         }
-        await this.ensureSession(account);
-        // In fetchproxy mode, login() never runs and therefore never calls
-        // discoverLinkedDistricts. Run discovery once on the first primary call
-        // so linked districts are discoverable. (The primary is never in
-        // linkedTo by construction.)
+        const session = await this.managers.get(account.name).ensure();
+        // In fetchproxy mode, the preloaded-cookie login never runs verify.jsp
+        // and therefore never calls discoverLinkedDistricts. Run discovery once
+        // on the first primary call so linked districts are discoverable. (The
+        // primary is never in linkedTo by construction.)
         if (this.fetchproxyMode && !this.fetchproxyDiscoveryRan && account.name === this.primaryName) {
             this.fetchproxyDiscoveryRan = true;
-            await this.discoverLinkedDistricts(account);
-        }
-        return this.doRequest(account, path, opts, false);
-    }
-    async ensureSession(account) {
-        let s = this.sessions.get(account.name);
-        if (s && Date.now() - s.loggedInAt < SESSION_TTL_MS)
-            return;
-        if (s?.loginInFlight) {
-            await s.loginInFlight;
-            return;
-        }
-        if (!s) {
-            s = { cookie: '', xsrfToken: '', loggedInAt: 0, loginInFlight: null };
-            this.sessions.set(account.name, s);
-        }
-        s.loginInFlight = this.login(account);
-        try {
-            await s.loginInFlight;
-        }
-        finally {
-            s.loginInFlight = null;
+            await this.discoverLinkedDistricts(account, session);
         }
+        return this.doRequest(account, path, opts);
     }
     async login(account) {
         // Linked districts have no real credentials of their own — they hold
         // synthetic '(linked)' placeholders and are authenticated by the primary's
-        // CUPS SSO switch, not by their own verify.jsp. When a linked-district
-        // session expires by TTL (vs. a 401, which doRequest already routes through
-        // the primary), ensureSession lands here. Re-login the primary, which
-        // re-runs discoverLinkedDistricts and re-establishes this district's
-        // session — POSTing the placeholder creds to verify.jsp would instead yield
-        // a misleading password-error. See the comment block at the top of the file.
+        // CUPS SSO switch, not by their own verify.jsp. Whether the linked session
+        // expired by TTL or by 401 (detectExpiredSession dropped the primary in
+        // that case), re-auth through the primary: refresh it, which re-runs
+        // discoverLinkedDistricts and `seed()`s a fresh session into this
+        // district's manager — POSTing the placeholder creds to verify.jsp would
+        // instead yield a misleading password-error.
+        //
+        // This runs as the linked manager's `login`, which `ensure()` only invokes
+        // after invalidating any stale session — so `current` is `undefined` on
+        // entry and becomes non-undefined ONLY if the primary refresh re-ran
+        // discovery and seeded us. If the primary was still fresh (or discovery
+        // failed to restore this district), `current` stays undefined — surface a
+        // clear error rather than handing callers a dead session.
         const primaryName = this.linkedTo.get(account.name);
         if (primaryName) {
-            // Drop the stale linked session so re-discovery installs a fresh one.
-            this.sessions.delete(account.name);
-            const primaryAccount = this.accounts.get(primaryName);
-            await this.ensureSession(primaryAccount);
-            // ensureSession(primary) re-ran login() → discoverLinkedDistricts(),
-            // which re-creates the linked session. If discovery failed to restore it,
-            // surface a clear error rather than leaving callers with a null session.
-            if (!this.sessions.has(account.name)) {
+            await this.managers.get(primaryName).ensure();
+            const restored = this.managers.get(account.name).current;
+            if (!restored) {
                 throw new AuthFailedError(account.name, 'linked-district session could not be re-established via the primary district', { credentialHint: false });
             }
-            return;
+            return restored;
+        }
+        // fetchproxy mode: the first primary login consumes the preloaded browser
+        // cookies instead of POSTing to verify.jsp. Consumed exactly once — after
+        // an expiry/invalidate there is nothing left to re-login with (below).
+        if (this.preloaded) {
+            const { cookieHeader, xsrfToken } = this.preloaded;
+            this.preloaded = null;
+            return { cookieHeader, xsrfToken };
         }
         // fetchproxy mode: empty primary creds, can't post to verify.jsp.
         // The user must re-sign-in in the browser (and the next process start
-        // will pick up the fresh cookies).
+        // will pick up the fresh cookies). Marked permanent: the manager caches
+        // and rethrows this instead of retrying a login that can never succeed.
         if (!account.username || !account.password) {
             throw new AuthFailedError(account.name, 'session expired and no IC_USERNAME/IC_PASSWORD set — ' +
-                'sign back into your IC portal in the browser and restart the MCP');
+                'sign back into your IC portal in the browser and restart the MCP', { permanent: true });
         }
         // ic_parent_api's pattern: single POST to verify.jsp, let the response
         // set cookies. No pre-login GET needed (unlike OFW's Spring Security).
@@ -185,23 +233,21 @@ export class ICClient {
         if (!cookies.cookieHeader) {
             throw new AuthFailedError(account.name, 'login response missing session cookies');
         }
-        // Mutate the in-map session in place so concurrent callers'
-        // references stay live (see ensureSession).
-        const session = this.sessions.get(account.name);
-        session.cookie = cookies.cookieHeader;
-        session.xsrfToken = cookies.xsrfToken;
-        session.loggedInAt = Date.now();
+        const session = {
+            cookieHeader: cookies.cookieHeader,
+            xsrfToken: cookies.xsrfToken,
+        };
         // Discover linked districts (CUPS SSO) — non-blocking, errors logged not
-        // thrown. By construction we only reach here for the primary (or fetchproxy
-        // primary): linked districts return early above and re-auth via the primary,
-        // so no `linkedTo` guard is needed.
-        await this.discoverLinkedDistricts(account);
+        // thrown. By construction we only reach here for the primary: linked
+        // districts return early above and re-auth via the primary, so no
+        // `linkedTo` guard is needed.
+        await this.discoverLinkedDistricts(account, session);
+        return session;
     }
-    async discoverLinkedDistricts(account) {
+    async discoverLinkedDistricts(account, session) {
         try {
-            const session = this.sessions.get(account.name);
             const baseHeaders = {
-                Cookie: session.cookie,
+                Cookie: session.cookieHeader,
                 Accept: 'application/json',
                 'Content-Type': 'application/json',
                 Referer: `${account.baseUrl}/campus/nav-wrapper/`,
@@ -261,7 +307,12 @@ export class ICClient {
                         console.error(`[ic] CUPS switch to ${linked.districtName}: no cookies`);
                         continue;
                     }
-                    // Store synthetic account + session
+                    // Store synthetic account + `seed()` the freshly-minted CUPS session
+                    // into the linked district's own manager. `seed()` installs it with a
+                    // fresh maxAgeMs clock and DETACHES any in-flight login — so when this
+                    // discovery is itself being awaited by a mid-flight linked `login()`
+                    // (the re-auth-through-primary path), that login's late resolution
+                    // won't overwrite the seed. The manager must exist before we seed it.
                     const syntheticAccount = {
                         name: linked.districtName,
                         baseUrl: linkedBaseUrl,
@@ -270,13 +321,14 @@ export class ICClient {
                         password: '(linked)',
                     };
                     this.accounts.set(linked.districtName, syntheticAccount);
-                    this.sessions.set(linked.districtName, {
-                        cookie: switchCookies.cookieHeader,
+                    this.linkedTo.set(linked.districtName, account.name);
+                    if (!this.managers.has(linked.districtName)) {
+                        this.managers.set(linked.districtName, this.makeManager(syntheticAccount));
+                    }
+                    this.managers.get(linked.districtName).seed({
+                        cookieHeader: switchCookies.cookieHeader,
                         xsrfToken: switchCookies.xsrfToken,
-                        loggedInAt: Date.now(),
-                        loginInFlight: null,
                     });
-                    this.linkedTo.set(linked.districtName, account.name);
                     console.error(`[ic] Linked district discovered: ${linked.districtName} (${linked.appName})`);
                 }
                 catch (e) {
@@ -310,14 +362,13 @@ export class ICClient {
         const account = this.accounts.get(district);
         if (!account)
             throw new UnknownDistrictError(district, [...this.accounts.keys()]);
-        await this.ensureSession(account);
-        const session = this.sessions.get(account.name);
+        const session = await this.managers.get(account.name).ensure();
         // Support both relative paths (/campus/...) and absolute URLs
         // (e.g. report-card URLs from ic_list_documents come fully-qualified).
         const url = /^https?:\/\//i.test(path) ? path : `${account.baseUrl}${path}`;
         const res = await fetch(url, {
             headers: {
-                Cookie: session.cookie,
+                Cookie: session.cookieHeader,
                 ...(session.xsrfToken ? { 'X-XSRF-TOKEN': session.xsrfToken } : {}),
             },
         });
@@ -331,37 +382,31 @@ export class ICClient {
             contentType: res.headers.get('content-type') ?? 'application/octet-stream',
         };
     }
-    async doRequest(account, path, opts, isRetry) {
-        const session = this.sessions.get(account.name);
+    async doRequest(account, path, opts) {
+        const mgr = this.managers.get(account.name);
         const accept = opts.responseType === 'text' ? 'text/html, text/plain, */*' : 'application/json';
-        const res = await fetch(`${account.baseUrl}${path}`, {
+        // withSession: on a 401 (detectExpiredSession, which also drops the
+        // primary + sibling sessions for a linked district), the manager
+        // invalidates this district, re-logs-in single-flight, and replays the
+        // request EXACTLY once.
+        const res = await mgr.withSession(async (session) => fetch(`${account.baseUrl}${path}`, {
             method: opts.method ?? 'GET',
             headers: {
-                Cookie: session.cookie,
+                Cookie: session.cookieHeader,
                 Accept: accept,
                 ...(session.xsrfToken ? { 'X-XSRF-TOKEN': session.xsrfToken } : {}),
                 ...(opts.headers ?? {}),
             },
             body: opts.body,
-        });
+        }));
         if (res.status === 401) {
-            if (isRetry)
-                throw new SessionExpiredError(account.name);
-            this.sessions.delete(account.name);
-            const primaryName = this.linkedTo.get(account.name);
-            if (primaryName) {
-                // Linked district 401: invalidate primary + all linked sessions so re-login rediscovers
-                this.sessions.delete(primaryName);
-                for (const [linked] of this.linkedTo) {
-                    this.sessions.delete(linked);
-                }
-                const primaryAccount = this.accounts.get(primaryName);
-                await this.ensureSession(primaryAccount);
-            }
-            else {
-                await this.ensureSession(account);
-            }
-            return this.doRequest(account, path, opts, true);
+            // We only reach here when the re-login SUCCEEDED but the replayed request
+            // 401'd again (a fresh session the portal still rejects). If the re-login
+            // itself failed, the `onReplayLoginError` hook already rethrew that
+            // error out of `withSession` — carrying the actionable message (e.g.
+            // fetchproxy's "sign back into your IC portal") — so control never
+            // reaches this branch in that case.
+            throw new SessionExpiredError(account.name);
         }
         if (res.status >= 500)
             throw new PortalUnreachableError(account.name, res.status);
@@ -380,24 +425,17 @@ export class ICClient {
  */
 function parseSetCookies(headers) {
     // Prefer the structured getSetCookie() split (one cookie per array entry,
-    // what real Node fetch Responses provide). Only when it's unavailable do we
-    // fall back to naively comma-splitting the joined header — kept identical to
-    // the original so the edge-case behavior (commas inside attribute lists) is
-    // preserved rather than inheriting parseCookieJar's smarter-but-different
-    // splitter. parseCookieJar then does the jar logic: drop deletion markers
+    // what real Node fetch Responses provide). When it's unavailable, hand the
+    // joined `set-cookie` string to parseCookieJar, which splits it defensively
+    // (safe around the commas inside `Expires` dates, unlike a naive comma
+    // split). parseCookieJar then does the jar logic: drop deletion markers
     // (Max-Age=0 / expired Expires) and empty values, dedupe by name. That's
     // load-bearing so the synthesized Cookie header never carries both the
     // `appName=` deletion and the real value (IC rejects "conflicting app name").
     const raw = headers.getSetCookie?.() ?? [];
-    const entries = raw.length > 0 ? raw : splitFallback(headers.get('set-cookie'));
-    const { cookies, cookieHeader } = parseCookieJar(entries);
+    const { cookies, cookieHeader } = parseCookieJar(raw.length > 0 ? raw : headers.get('set-cookie'));
     return { cookieHeader, xsrfToken: cookies['XSRF-TOKEN'] ?? '' };
 }
-function splitFallback(header) {
-    if (!header)
-        return [];
-    return header.split(',').map((s) => s.trim());
-}
 export class UnknownDistrictError extends Error {
     district;
     available;
@@ -411,11 +449,19 @@ export class UnknownDistrictError extends Error {
 export class AuthFailedError extends Error {
     district;
     reason;
+    /**
+     * A *permanent* configuration failure: retrying the login inside this
+     * process can never succeed (e.g. fetchproxy mode with no creds — the user
+     * must re-sign-in in the browser and restart). CookieSessionManager caches
+     * and rethrows permanent errors instead of retrying.
+     */
+    permanent;
     /**
      * @param opts.credentialHint When `false`, the message omits the
      *   "Check IC_USERNAME and IC_PASSWORD" suffix — used for failures where the
      *   credentials are known-good (e.g. a linked-district CUPS/SSO re-discovery
      *   failure) and pointing the user at their creds would be misleading.
+     * @param opts.permanent See {@link AuthFailedError.permanent}.
      */
     constructor(district, reason, opts) {
         const detail = reason ? ` (${reason})` : '';
@@ -427,6 +473,7 @@ export class AuthFailedError extends Error {
         this.district = district;
         this.reason = reason;
         this.name = 'AuthFailedError';
+        this.permanent = opts?.permanent ?? false;
     }
 }
 export class PortalUnreachableError extends Error {

package/dist/index.js

@@ -57,7 +57,7 @@ catch (e) {
 // actionable stderr message (banner) instead of a crash loop.
 const COMMON = {
     name: 'infinitecampus',
-    version: '2.3.4', // x-release-please-version
+    version: '2.3.6', // x-release-please-version
 };
 if (account) {
     const client = new ICClient(account, { preloaded });

package/dist/tools/_shared.js

@@ -1,20 +1,11 @@
 import { textResult } from '@chrischall/mcp-utils';
-/**
- * Wrap a value as an MCP text content block — the standard tool return shape.
- * Thin re-export of mcp-utils' `textResult` so the whole fleet shares one
- * pretty-printed-JSON formatter; the local name is kept to avoid churning
- * every tool call site.
- */
-export function textContent(data) {
-    return textResult(data);
-}
 /** Detect "IC 404 ..." errors thrown by ICClient.request for endpoints that don't exist. */
 export function is404(e) {
     return e instanceof Error && e.message.startsWith('IC 404 ');
 }
 /** Build a FeatureDisabled warning content block. */
 export function featureDisabled(feature, district, data = []) {
-    return textContent({ warning: 'FeatureDisabled', feature, district, data });
+    return textResult({ warning: 'FeatureDisabled', feature, district, data });
 }
 /** Fetch the students list and find the one matching studentId. Returns null if not found. */
 export async function findStudent(client, district, studentId) {
@@ -23,7 +14,7 @@ export async function findStudent(client, district, studentId) {
 }
 /** Standard error content block for when studentId doesn't match any student. */
 export function studentNotFound(studentId) {
-    return textContent({ error: 'StudentNotFound', studentId });
+    return textResult({ error: 'StudentNotFound', studentId });
 }
 /**
  * Check a feature flag via the district's displayOptions allow-list for the

package/dist/tools/assessments.js

@@ -1,5 +1,6 @@
+import { textResult } from '@chrischall/mcp-utils';
 import { z } from 'zod';
-import { textContent, findStudent, studentNotFound, featureDisabled, is404, toArray, checkFeatureDisabled } from './_shared.js';
+import { findStudent, studentNotFound, featureDisabled, is404, toArray, checkFeatureDisabled } from './_shared.js';
 const argsSchema = z.object({
     district: z.string(),
     studentId: z.string().describe('Student personID from ic_list_students'),
@@ -48,6 +49,6 @@ export function registerAssessmentTools(server, client) {
         if (feature404 && result.length === 0) {
             return featureDisabled('assessments', args.district);
         }
-        return textContent(result);
+        return textResult(result);
     });
 }

package/dist/tools/assignments.js

@@ -1,5 +1,5 @@
+import { textResult } from '@chrischall/mcp-utils';
 import { z } from 'zod';
-import { textContent } from './_shared.js';
 const argsSchema = z.object({
     district: z.string(),
     studentId: z.string(),
@@ -33,6 +33,6 @@ export function registerAssignmentTools(server, client) {
         if (args.missingOnly) {
             data = data.filter((a) => a.missing);
         }
-        return textContent(data);
+        return textResult(data);
     });
 }

package/dist/tools/attendance.js

@@ -1,5 +1,6 @@
+import { textResult } from '@chrischall/mcp-utils';
 import { z } from 'zod';
-import { textContent, is404, featureDisabled, findStudent, studentNotFound, toArray, checkFeatureDisabled } from './_shared.js';
+import { is404, featureDisabled, findStudent, studentNotFound, toArray, checkFeatureDisabled } from './_shared.js';
 const argsSchema = z.object({
     district: z.string(),
     studentId: z.string(),
@@ -70,7 +71,7 @@ export function registerAttendanceTools(server, client) {
                     results.push({ ...entry, terms: trimmedTerms });
                 }
             }
-            return textContent(results);
+            return textResult(results);
         }
         catch (e) {
             if (is404(e))

package/dist/tools/attendance_events.js

@@ -1,5 +1,6 @@
+import { textResult } from '@chrischall/mcp-utils';
 import { z } from 'zod';
-import { textContent, is404, featureDisabled, findStudent, studentNotFound, toArray, checkFeatureDisabled } from './_shared.js';
+import { is404, featureDisabled, findStudent, studentNotFound, toArray, checkFeatureDisabled } from './_shared.js';
 const argsSchema = z.object({
     district: z.string(),
     studentId: z.string().describe('Student personID from ic_list_students'),
@@ -78,7 +79,7 @@ export function registerAttendanceEventsTools(server, client) {
                     results.push(trimmed);
                 }
             }
-            return textContent(results);
+            return textResult(results);
         }
         catch (e) {
             if (is404(e))

package/dist/tools/behavior.js

@@ -1,5 +1,6 @@
+import { textResult } from '@chrischall/mcp-utils';
 import { z } from 'zod';
-import { textContent, is404, featureDisabled, findStudent, studentNotFound, checkFeatureDisabled } from './_shared.js';
+import { is404, featureDisabled, findStudent, studentNotFound, checkFeatureDisabled } from './_shared.js';
 const argsSchema = z.object({
     district: z.string(),
     studentId: z.string(),
@@ -26,7 +27,7 @@ export function registerBehaviorTools(server, client) {
             params.set('endDate', args.until);
         try {
             const data = await client.request(args.district, `/campus/resources/portal/behavior?${params}`);
-            return textContent(data);
+            return textResult(data);
         }
         catch (e) {
             if (is404(e))

package/dist/tools/calendar.js

@@ -1,5 +1,6 @@
+import { textResult } from '@chrischall/mcp-utils';
 import { z } from 'zod';
-import { textContent, findStudent, studentNotFound, toArray } from './_shared.js';
+import { findStudent, studentNotFound, toArray } from './_shared.js';
 const argsSchema = z.object({
     district: z.string(),
     studentId: z.string().describe('Student personID from ic_list_students'),
@@ -63,6 +64,6 @@ export function registerCalendarTools(server, client) {
                 terms: trimmedTerms,
             });
         }
-        return textContent(result);
+        return textResult(result);
     });
 }

package/dist/tools/districts.js

@@ -1,4 +1,4 @@
-import { textContent } from './_shared.js';
+import { textResult } from '@chrischall/mcp-utils';
 export function registerDistrictTools(server, client) {
     server.registerTool('ic_list_districts', {
         description: 'List Infinite Campus districts configured for this MCP server. Returns names + base URLs (no credentials).',
@@ -6,6 +6,6 @@ export function registerDistrictTools(server, client) {
     }, async () => {
         await client.ensureDiscovery();
         const data = client.listDistricts();
-        return textContent(data);
+        return textResult(data);
     });
 }

package/dist/tools/documents.js

@@ -1,5 +1,6 @@
+import { textResult } from '@chrischall/mcp-utils';
 import { z } from 'zod';
-import { textContent, is404, featureDisabled, toArray, findStudent, studentNotFound, checkFeatureDisabled } from './_shared.js';
+import { is404, featureDisabled, toArray, findStudent, studentNotFound, checkFeatureDisabled } from './_shared.js';
 const listArgs = z.object({
     district: z.string(),
     studentId: z.string(),
@@ -39,7 +40,7 @@ export function registerDocumentTools(server, client) {
                     out.endYear = d.endYear;
                 return out;
             });
-            return textContent(trimmed);
+            return textResult(trimmed);
         }
         catch (e) {
             if (is404(e))
@@ -57,11 +58,11 @@ export function registerDocumentTools(server, client) {
             const meta = await client.download(args.district, args.documentId, args.destinationPath, {
                 overwrite: args.overwrite ?? false,
             });
-            return textContent(meta);
+            return textResult(meta);
         }
         catch (e) {
             if (e instanceof Error && e.message.startsWith('IC download 404')) {
-                return textContent({ warning: 'FeatureDisabled', feature: 'documents', district: args.district });
+                return textResult({ warning: 'FeatureDisabled', feature: 'documents', district: args.district });
             }
             throw e;
         }

package/dist/tools/features.js

@@ -1,5 +1,6 @@
+import { textResult } from '@chrischall/mcp-utils';
 import { z } from 'zod';
-import { textContent, findStudent, studentNotFound } from './_shared.js';
+import { findStudent, studentNotFound } from './_shared.js';
 const argsSchema = z.object({
     district: z.string(),
     studentId: z.string().describe('Student personID from ic_list_students'),
@@ -24,6 +25,6 @@ export function registerFeaturesTools(server, client) {
                 features,
             });
         }
-        return textContent(result);
+        return textResult(result);
     });
 }

package/dist/tools/fees.js

@@ -1,5 +1,6 @@
+import { textResult } from '@chrischall/mcp-utils';
 import { z } from 'zod';
-import { textContent, is404, featureDisabled } from './_shared.js';
+import { is404, featureDisabled } from './_shared.js';
 const argsSchema = z.object({
     district: z.string(),
     studentId: z.string().describe('Student personID from ic_list_students'),
@@ -38,6 +39,6 @@ export function registerFeeTools(server, client) {
             feeAssignments: assignments.ok ? assignments.value : [],
             ...(issues.length > 0 ? { issues } : {}),
         };
-        return textContent(response);
+        return textResult(response);
     });
 }